771 lines
23 KiB
Rust
771 lines
23 KiB
Rust
use axum::{
|
|
Json,
|
|
extract::{Path, Query, State},
|
|
http::StatusCode,
|
|
response::IntoResponse,
|
|
};
|
|
use uuid::Uuid;
|
|
|
|
use std::str::FromStr;
|
|
|
|
use application::{
|
|
commands::{
|
|
DeleteReviewCommand, ExportCommand, LoginCommand, RegisterCommand, SyncPosterCommand,
|
|
},
|
|
queries::{
|
|
GetActivityFeedQuery, GetMovieSocialPageQuery, GetReviewHistoryQuery, GetUserProfileQuery,
|
|
GetUsersQuery,
|
|
},
|
|
use_cases::{
|
|
delete_review, export_diary as export_diary_uc, get_activity_feed as get_feed_uc,
|
|
get_diary, get_movie_social_page, get_review_history,
|
|
get_user_profile as get_user_profile_uc, get_users, log_review, login as login_uc,
|
|
register as register_uc, sync_poster,
|
|
},
|
|
};
|
|
use domain::{
|
|
errors::DomainError,
|
|
models::{DiaryEntry, ExportFormat, Movie, Review},
|
|
services::review_history::Trend,
|
|
value_objects::{MovieId, UserId},
|
|
};
|
|
|
|
#[cfg(feature = "federation")]
|
|
use crate::dtos::{ActorListResponse, ActorUrlRequest, FollowRequest, RemoteActorDto};
|
|
use crate::{
|
|
dtos::{
|
|
ActivityFeedQueryParams, ActivityFeedResponse, DiaryEntryDto, DiaryQueryParams,
|
|
DiaryResponse, DirectorStatDto, ExportQueryParams, FeedEntryDto, LogReviewData,
|
|
LogReviewRequest, LoginRequest, LoginResponse, MonthActivityDto, MonthlyRatingDto,
|
|
MovieDetailResponse, MovieDto, MovieStatsDto, PaginationQueryParams, RegisterRequest,
|
|
ReviewDto, ReviewHistoryResponse, SocialFeedResponse, SocialReviewDto,
|
|
UserProfileQueryParams, UserProfileResponse, UserStatsDto, UserSummaryDto, UserTrendsDto,
|
|
UsersResponse,
|
|
},
|
|
errors::ApiError,
|
|
extractors::AuthenticatedUser,
|
|
state::AppState,
|
|
};
|
|
|
|
#[utoipa::path(
|
|
get, path = "/api/v1/diary",
|
|
params(DiaryQueryParams),
|
|
responses(
|
|
(status = 200, body = DiaryResponse),
|
|
(status = 401, description = "Unauthorized"),
|
|
),
|
|
security(("bearer_auth" = []))
|
|
)]
|
|
pub async fn get_diary(
|
|
State(state): State<AppState>,
|
|
Query(params): Query<DiaryQueryParams>,
|
|
) -> Result<Json<DiaryResponse>, ApiError> {
|
|
let page = get_diary::execute(&state.app_ctx, params.into()).await?;
|
|
|
|
Ok(Json(DiaryResponse {
|
|
items: page.items.iter().map(entry_to_dto).collect(),
|
|
total_count: page.total_count,
|
|
limit: page.limit,
|
|
offset: page.offset,
|
|
}))
|
|
}
|
|
|
|
#[utoipa::path(
|
|
get, path = "/api/v1/movies/{id}/history",
|
|
params(("id" = Uuid, Path, description = "Movie ID")),
|
|
responses(
|
|
(status = 200, body = ReviewHistoryResponse),
|
|
(status = 404, description = "Movie not found"),
|
|
)
|
|
)]
|
|
pub async fn get_review_history(
|
|
State(state): State<AppState>,
|
|
Path(movie_id): Path<Uuid>,
|
|
) -> Result<Json<ReviewHistoryResponse>, ApiError> {
|
|
let (history, trend) =
|
|
get_review_history::execute(&state.app_ctx, GetReviewHistoryQuery { movie_id }).await?;
|
|
|
|
Ok(Json(ReviewHistoryResponse {
|
|
movie: movie_to_dto(history.movie()),
|
|
viewings: history.viewings().iter().map(review_to_dto).collect(),
|
|
trend: match trend {
|
|
Trend::Improved => "improved",
|
|
Trend::Declined => "declined",
|
|
Trend::Neutral => "neutral",
|
|
}
|
|
.to_string(),
|
|
}))
|
|
}
|
|
|
|
#[utoipa::path(
|
|
post, path = "/api/v1/reviews",
|
|
request_body = LogReviewRequest,
|
|
responses(
|
|
(status = 201, description = "Review created"),
|
|
(status = 400, description = "Invalid input"),
|
|
(status = 401, description = "Unauthorized"),
|
|
),
|
|
security(("bearer_auth" = []))
|
|
)]
|
|
pub async fn post_review(
|
|
State(state): State<AppState>,
|
|
user: AuthenticatedUser,
|
|
Json(req): Json<LogReviewRequest>,
|
|
) -> Result<impl IntoResponse, ApiError> {
|
|
let data = LogReviewData::try_from(req).map_err(ApiError)?;
|
|
log_review::execute(&state.app_ctx, data.into_command(user.0.value())).await?;
|
|
Ok(StatusCode::CREATED)
|
|
}
|
|
|
|
#[utoipa::path(
|
|
post, path = "/api/v1/movies/{id}/sync-poster",
|
|
params(("id" = Uuid, Path, description = "Movie ID")),
|
|
responses(
|
|
(status = 204, description = "Poster synced"),
|
|
(status = 401, description = "Unauthorized"),
|
|
(status = 404, description = "Movie not found"),
|
|
),
|
|
security(("bearer_auth" = []))
|
|
)]
|
|
pub async fn sync_poster(
|
|
State(state): State<AppState>,
|
|
_user: AuthenticatedUser,
|
|
Path(movie_id): Path<Uuid>,
|
|
) -> Result<impl IntoResponse, ApiError> {
|
|
let movie = state
|
|
.app_ctx
|
|
.movie_repository
|
|
.get_movie_by_id(&MovieId::from_uuid(movie_id))
|
|
.await?
|
|
.ok_or_else(|| ApiError(DomainError::NotFound(format!("Movie {movie_id}"))))?;
|
|
|
|
let external_id = movie
|
|
.external_metadata_id()
|
|
.ok_or_else(|| {
|
|
ApiError(DomainError::ValidationError(
|
|
"Movie has no external metadata ID, cannot sync poster".into(),
|
|
))
|
|
})?
|
|
.value()
|
|
.to_string();
|
|
|
|
sync_poster::execute(
|
|
&state.app_ctx,
|
|
SyncPosterCommand {
|
|
movie_id,
|
|
external_metadata_id: external_id,
|
|
},
|
|
)
|
|
.await?;
|
|
|
|
Ok(StatusCode::NO_CONTENT)
|
|
}
|
|
|
|
#[utoipa::path(
|
|
post, path = "/api/v1/auth/login",
|
|
request_body = LoginRequest,
|
|
responses(
|
|
(status = 200, body = LoginResponse),
|
|
(status = 401, description = "Invalid credentials"),
|
|
)
|
|
)]
|
|
pub async fn login(
|
|
State(state): State<AppState>,
|
|
Json(req): Json<LoginRequest>,
|
|
) -> Result<Json<LoginResponse>, ApiError> {
|
|
let result = login_uc::execute(
|
|
&state.app_ctx,
|
|
LoginCommand {
|
|
email: req.email,
|
|
password: req.password,
|
|
},
|
|
)
|
|
.await?;
|
|
Ok(Json(LoginResponse {
|
|
token: result.token,
|
|
user_id: result.user_id,
|
|
email: result.email,
|
|
expires_at: result.expires_at.to_rfc3339(),
|
|
}))
|
|
}
|
|
|
|
#[utoipa::path(
|
|
post, path = "/api/v1/auth/register",
|
|
request_body = RegisterRequest,
|
|
responses(
|
|
(status = 201, description = "User registered"),
|
|
(status = 400, description = "Invalid input"),
|
|
)
|
|
)]
|
|
pub async fn register(
|
|
State(state): State<AppState>,
|
|
Json(req): Json<RegisterRequest>,
|
|
) -> Result<StatusCode, ApiError> {
|
|
register_uc::execute(
|
|
&state.app_ctx,
|
|
RegisterCommand {
|
|
email: req.email,
|
|
username: req.username,
|
|
password: req.password,
|
|
role: domain::models::UserRole::Standard,
|
|
},
|
|
)
|
|
.await?;
|
|
Ok(StatusCode::CREATED)
|
|
}
|
|
|
|
#[utoipa::path(
|
|
delete, path = "/api/v1/reviews/{id}",
|
|
params(("id" = Uuid, Path, description = "Review ID")),
|
|
responses(
|
|
(status = 204, description = "Review deleted"),
|
|
(status = 401, description = "Unauthorized"),
|
|
(status = 403, description = "Forbidden"),
|
|
(status = 404, description = "Review not found"),
|
|
),
|
|
security(("bearer_auth" = []))
|
|
)]
|
|
pub async fn delete_review(
|
|
State(state): State<AppState>,
|
|
AuthenticatedUser(user_id): AuthenticatedUser,
|
|
Path(review_id): Path<Uuid>,
|
|
) -> impl IntoResponse {
|
|
let cmd = DeleteReviewCommand {
|
|
review_id,
|
|
requesting_user_id: user_id.value(),
|
|
};
|
|
match delete_review::execute(&state.app_ctx, cmd).await {
|
|
Ok(()) => StatusCode::NO_CONTENT.into_response(),
|
|
Err(DomainError::NotFound(_)) => StatusCode::NOT_FOUND.into_response(),
|
|
Err(DomainError::Unauthorized(_)) => StatusCode::FORBIDDEN.into_response(),
|
|
Err(e) => {
|
|
tracing::error!("delete_review error: {:?}", e);
|
|
StatusCode::INTERNAL_SERVER_ERROR.into_response()
|
|
}
|
|
}
|
|
}
|
|
|
|
#[utoipa::path(
|
|
get, path = "/api/v1/movies/{movie_id}",
|
|
params(("movie_id" = Uuid, Path, description = "Movie ID")),
|
|
responses(
|
|
(status = 200, body = MovieDetailResponse),
|
|
(status = 404, description = "Movie not found"),
|
|
)
|
|
)]
|
|
pub async fn get_movie_detail(
|
|
State(state): State<AppState>,
|
|
Path(movie_id): Path<Uuid>,
|
|
Query(params): Query<PaginationQueryParams>,
|
|
) -> Result<Json<MovieDetailResponse>, ApiError> {
|
|
let limit = params.limit.unwrap_or(20);
|
|
let offset = params.offset.unwrap_or(0);
|
|
|
|
let result = get_movie_social_page::execute(
|
|
&state.app_ctx,
|
|
GetMovieSocialPageQuery { movie_id, limit, offset },
|
|
)
|
|
.await?;
|
|
|
|
Ok(Json(MovieDetailResponse {
|
|
movie: movie_to_dto(&result.movie),
|
|
stats: MovieStatsDto {
|
|
total_count: result.stats.total_count,
|
|
avg_rating: result.stats.avg_rating,
|
|
federated_count: result.stats.federated_count,
|
|
rating_histogram: result.stats.rating_histogram,
|
|
},
|
|
reviews: SocialFeedResponse {
|
|
items: result.reviews.items.iter().map(|e| SocialReviewDto {
|
|
user_display: e.user_display_name().to_string(),
|
|
rating: e.review().rating().value(),
|
|
comment: e.review().comment().map(|c| c.value().to_string()),
|
|
watched_at: e.review().watched_at().to_string(),
|
|
is_federated: e.review().is_remote(),
|
|
}).collect(),
|
|
total_count: result.reviews.total_count,
|
|
limit: result.reviews.limit,
|
|
offset: result.reviews.offset,
|
|
},
|
|
}))
|
|
}
|
|
|
|
fn movie_to_dto(movie: &Movie) -> MovieDto {
|
|
MovieDto {
|
|
id: movie.id().value(),
|
|
title: movie.title().value().to_string(),
|
|
release_year: movie.release_year().value(),
|
|
director: movie.director().map(|d| d.to_string()),
|
|
poster_path: movie.poster_path().map(|p| p.value().to_string()),
|
|
}
|
|
}
|
|
|
|
fn review_to_dto(review: &Review) -> ReviewDto {
|
|
ReviewDto {
|
|
id: review.id().value(),
|
|
rating: review.rating().value(),
|
|
comment: review.comment().map(|c| c.value().to_string()),
|
|
watched_at: review.watched_at().to_string(),
|
|
}
|
|
}
|
|
|
|
fn entry_to_dto(entry: &DiaryEntry) -> DiaryEntryDto {
|
|
DiaryEntryDto {
|
|
movie: movie_to_dto(entry.movie()),
|
|
review: review_to_dto(entry.review()),
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "federation")]
|
|
fn ap_err(e: anyhow::Error) -> impl IntoResponse {
|
|
tracing::error!("ActivityPub error: {:?}", e);
|
|
StatusCode::INTERNAL_SERVER_ERROR
|
|
}
|
|
|
|
#[cfg(feature = "federation")]
|
|
#[utoipa::path(
|
|
get, path = "/api/v1/social/following",
|
|
responses(
|
|
(status = 200, body = ActorListResponse),
|
|
(status = 401, description = "Unauthorized"),
|
|
),
|
|
security(("bearer_auth" = []))
|
|
)]
|
|
pub async fn get_following(
|
|
State(state): State<AppState>,
|
|
user: AuthenticatedUser,
|
|
) -> impl IntoResponse {
|
|
match state.ap_service.get_following(user.0.value()).await {
|
|
Ok(actors) => Json(ActorListResponse {
|
|
actors: actors
|
|
.into_iter()
|
|
.map(|a| RemoteActorDto {
|
|
handle: a.handle,
|
|
display_name: a.display_name,
|
|
url: a.url,
|
|
})
|
|
.collect(),
|
|
})
|
|
.into_response(),
|
|
Err(e) => ap_err(e).into_response(),
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "federation")]
|
|
#[utoipa::path(
|
|
get, path = "/api/v1/social/followers",
|
|
responses(
|
|
(status = 200, body = ActorListResponse),
|
|
(status = 401, description = "Unauthorized"),
|
|
),
|
|
security(("bearer_auth" = []))
|
|
)]
|
|
pub async fn get_followers(
|
|
State(state): State<AppState>,
|
|
user: AuthenticatedUser,
|
|
) -> impl IntoResponse {
|
|
match state
|
|
.ap_service
|
|
.get_accepted_followers(user.0.value())
|
|
.await
|
|
{
|
|
Ok(actors) => Json(ActorListResponse {
|
|
actors: actors
|
|
.into_iter()
|
|
.map(|a| RemoteActorDto {
|
|
handle: a.handle,
|
|
display_name: a.display_name,
|
|
url: a.url,
|
|
})
|
|
.collect(),
|
|
})
|
|
.into_response(),
|
|
Err(e) => ap_err(e).into_response(),
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "federation")]
|
|
#[utoipa::path(
|
|
post, path = "/api/v1/social/follow",
|
|
request_body = FollowRequest,
|
|
responses(
|
|
(status = 200, description = "Follow request sent"),
|
|
(status = 401, description = "Unauthorized"),
|
|
),
|
|
security(("bearer_auth" = []))
|
|
)]
|
|
pub async fn follow(
|
|
State(state): State<AppState>,
|
|
user: AuthenticatedUser,
|
|
Json(body): Json<FollowRequest>,
|
|
) -> impl IntoResponse {
|
|
match state.ap_service.follow(user.0.value(), &body.handle).await {
|
|
Ok(()) => StatusCode::OK.into_response(),
|
|
Err(e) => ap_err(e).into_response(),
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "federation")]
|
|
#[utoipa::path(
|
|
post, path = "/api/v1/social/unfollow",
|
|
request_body = ActorUrlRequest,
|
|
responses(
|
|
(status = 200, description = "Unfollowed"),
|
|
(status = 401, description = "Unauthorized"),
|
|
),
|
|
security(("bearer_auth" = []))
|
|
)]
|
|
pub async fn unfollow(
|
|
State(state): State<AppState>,
|
|
user: AuthenticatedUser,
|
|
Json(body): Json<ActorUrlRequest>,
|
|
) -> impl IntoResponse {
|
|
match state
|
|
.ap_service
|
|
.unfollow(user.0.value(), &body.actor_url)
|
|
.await
|
|
{
|
|
Ok(()) => StatusCode::OK.into_response(),
|
|
Err(e) => ap_err(e).into_response(),
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "federation")]
|
|
#[utoipa::path(
|
|
post, path = "/api/v1/social/followers/accept",
|
|
request_body = ActorUrlRequest,
|
|
responses(
|
|
(status = 200, description = "Follower accepted"),
|
|
(status = 401, description = "Unauthorized"),
|
|
),
|
|
security(("bearer_auth" = []))
|
|
)]
|
|
pub async fn accept_follower(
|
|
State(state): State<AppState>,
|
|
user: AuthenticatedUser,
|
|
Json(body): Json<ActorUrlRequest>,
|
|
) -> impl IntoResponse {
|
|
match state
|
|
.ap_service
|
|
.accept_follower(user.0.value(), &body.actor_url)
|
|
.await
|
|
{
|
|
Ok(()) => StatusCode::OK.into_response(),
|
|
Err(e) => ap_err(e).into_response(),
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "federation")]
|
|
#[utoipa::path(
|
|
post, path = "/api/v1/social/followers/reject",
|
|
request_body = ActorUrlRequest,
|
|
responses(
|
|
(status = 200, description = "Follower rejected"),
|
|
(status = 401, description = "Unauthorized"),
|
|
),
|
|
security(("bearer_auth" = []))
|
|
)]
|
|
pub async fn reject_follower(
|
|
State(state): State<AppState>,
|
|
user: AuthenticatedUser,
|
|
Json(body): Json<ActorUrlRequest>,
|
|
) -> impl IntoResponse {
|
|
match state
|
|
.ap_service
|
|
.reject_follower(user.0.value(), &body.actor_url)
|
|
.await
|
|
{
|
|
Ok(()) => StatusCode::OK.into_response(),
|
|
Err(e) => ap_err(e).into_response(),
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "federation")]
|
|
#[utoipa::path(
|
|
post, path = "/api/v1/social/followers/remove",
|
|
request_body = ActorUrlRequest,
|
|
responses(
|
|
(status = 200, description = "Follower removed"),
|
|
(status = 401, description = "Unauthorized"),
|
|
),
|
|
security(("bearer_auth" = []))
|
|
)]
|
|
pub async fn remove_follower(
|
|
State(state): State<AppState>,
|
|
user: AuthenticatedUser,
|
|
Json(body): Json<ActorUrlRequest>,
|
|
) -> impl IntoResponse {
|
|
match state
|
|
.ap_service
|
|
.remove_follower(user.0.value(), &body.actor_url)
|
|
.await
|
|
{
|
|
Ok(()) => StatusCode::OK.into_response(),
|
|
Err(e) => ap_err(e).into_response(),
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "federation")]
|
|
#[utoipa::path(
|
|
get, path = "/api/v1/social/followers/pending",
|
|
responses(
|
|
(status = 200, body = ActorListResponse),
|
|
(status = 401, description = "Unauthorized"),
|
|
),
|
|
security(("bearer_auth" = []))
|
|
)]
|
|
pub async fn get_pending_followers(
|
|
State(state): State<AppState>,
|
|
user: AuthenticatedUser,
|
|
) -> impl IntoResponse {
|
|
match state.ap_service.get_pending_followers(user.0.value()).await {
|
|
Ok(actors) => Json(ActorListResponse {
|
|
actors: actors
|
|
.into_iter()
|
|
.map(|a| RemoteActorDto {
|
|
handle: a.handle,
|
|
display_name: a.display_name,
|
|
url: a.url,
|
|
})
|
|
.collect(),
|
|
})
|
|
.into_response(),
|
|
Err(e) => ap_err(e).into_response(),
|
|
}
|
|
}
|
|
|
|
#[utoipa::path(
|
|
get, path = "/api/v1/activity-feed",
|
|
params(ActivityFeedQueryParams),
|
|
responses((status = 200, body = ActivityFeedResponse)),
|
|
)]
|
|
pub async fn get_activity_feed(
|
|
State(state): State<AppState>,
|
|
Query(params): Query<ActivityFeedQueryParams>,
|
|
) -> Result<Json<ActivityFeedResponse>, ApiError> {
|
|
let page = get_feed_uc::execute(
|
|
&state.app_ctx,
|
|
GetActivityFeedQuery {
|
|
limit: params.limit.unwrap_or(20),
|
|
offset: params.offset.unwrap_or(0),
|
|
sort_by: domain::ports::FeedSortBy::Date,
|
|
search: None,
|
|
following: None,
|
|
},
|
|
)
|
|
.await?;
|
|
Ok(Json(ActivityFeedResponse {
|
|
items: page
|
|
.items
|
|
.iter()
|
|
.map(|e| FeedEntryDto {
|
|
movie: movie_to_dto(e.movie()),
|
|
review: review_to_dto(e.review()),
|
|
user_email: e.user_email().to_string(),
|
|
user_display_name: e.user_display_name().to_string(),
|
|
})
|
|
.collect(),
|
|
total_count: page.total_count,
|
|
limit: page.limit,
|
|
offset: page.offset,
|
|
}))
|
|
}
|
|
|
|
#[utoipa::path(
|
|
get, path = "/api/v1/users",
|
|
responses((status = 200, body = UsersResponse)),
|
|
)]
|
|
pub async fn list_users(
|
|
State(state): State<AppState>,
|
|
) -> Result<Json<UsersResponse>, ApiError> {
|
|
let users = get_users::execute(&state.app_ctx, GetUsersQuery).await?;
|
|
Ok(Json(UsersResponse {
|
|
users: users
|
|
.iter()
|
|
.map(|u| UserSummaryDto {
|
|
id: u.user_id.value(),
|
|
email: u.email().to_string(),
|
|
total_movies: u.total_movies,
|
|
avg_rating: u.avg_rating,
|
|
})
|
|
.collect(),
|
|
}))
|
|
}
|
|
|
|
#[utoipa::path(
|
|
get, path = "/api/v1/users/{id}",
|
|
params(
|
|
("id" = Uuid, Path, description = "User ID"),
|
|
UserProfileQueryParams,
|
|
),
|
|
responses(
|
|
(status = 200, body = UserProfileResponse),
|
|
(status = 404, description = "User not found"),
|
|
)
|
|
)]
|
|
pub async fn get_user_profile(
|
|
State(state): State<AppState>,
|
|
Path(user_id): Path<Uuid>,
|
|
Query(params): Query<UserProfileQueryParams>,
|
|
) -> impl IntoResponse {
|
|
let view_str = params.view.as_deref().unwrap_or("recent");
|
|
let profile_view = match application::queries::ProfileView::from_str(view_str) {
|
|
Ok(v) => v,
|
|
Err(_) => return StatusCode::BAD_REQUEST.into_response(),
|
|
};
|
|
|
|
let user = match state
|
|
.app_ctx
|
|
.user_repository
|
|
.find_by_id(&UserId::from_uuid(user_id))
|
|
.await
|
|
{
|
|
Ok(Some(u)) => u,
|
|
Ok(None) => return StatusCode::NOT_FOUND.into_response(),
|
|
Err(e) => {
|
|
tracing::error!("user lookup: {:?}", e);
|
|
return StatusCode::INTERNAL_SERVER_ERROR.into_response();
|
|
}
|
|
};
|
|
|
|
let profile = match get_user_profile_uc::execute(
|
|
&state.app_ctx,
|
|
GetUserProfileQuery {
|
|
user_id,
|
|
view: profile_view,
|
|
limit: params.limit,
|
|
offset: params.offset,
|
|
sort_by: domain::ports::FeedSortBy::Date,
|
|
search: None,
|
|
},
|
|
)
|
|
.await
|
|
{
|
|
Ok(p) => p,
|
|
Err(e) => {
|
|
tracing::error!("profile: {:?}", e);
|
|
return StatusCode::INTERNAL_SERVER_ERROR.into_response();
|
|
}
|
|
};
|
|
|
|
#[cfg(feature = "federation")]
|
|
let following_count = state.ap_service.count_following(user_id).await.unwrap_or(0);
|
|
#[cfg(not(feature = "federation"))]
|
|
let following_count = 0usize;
|
|
|
|
#[cfg(feature = "federation")]
|
|
let followers_count = state
|
|
.ap_service
|
|
.count_accepted_followers(user_id)
|
|
.await
|
|
.unwrap_or(0);
|
|
#[cfg(not(feature = "federation"))]
|
|
let followers_count = 0usize;
|
|
|
|
let entries = profile.entries.map(|p| DiaryResponse {
|
|
items: p.items.iter().map(entry_to_dto).collect(),
|
|
total_count: p.total_count,
|
|
limit: p.limit,
|
|
offset: p.offset,
|
|
});
|
|
|
|
let history = profile.history.map(|months| {
|
|
months
|
|
.into_iter()
|
|
.map(|m| MonthActivityDto {
|
|
year_month: m.year_month,
|
|
month_label: m.month_label,
|
|
count: m.count,
|
|
entries: m.entries.iter().map(entry_to_dto).collect(),
|
|
})
|
|
.collect()
|
|
});
|
|
|
|
let trends = profile.trends.map(|t| UserTrendsDto {
|
|
monthly_ratings: t
|
|
.monthly_ratings
|
|
.into_iter()
|
|
.map(|r| MonthlyRatingDto {
|
|
year_month: r.year_month,
|
|
month_label: r.month_label,
|
|
avg_rating: r.avg_rating,
|
|
count: r.count,
|
|
})
|
|
.collect(),
|
|
top_directors: t
|
|
.top_directors
|
|
.into_iter()
|
|
.map(|d| DirectorStatDto {
|
|
director: d.director,
|
|
count: d.count,
|
|
})
|
|
.collect(),
|
|
max_director_count: t.max_director_count,
|
|
});
|
|
|
|
Json(UserProfileResponse {
|
|
user_id,
|
|
username: user.username().value().to_string(),
|
|
stats: UserStatsDto {
|
|
total_movies: profile.stats.total_movies,
|
|
avg_rating: profile.stats.avg_rating,
|
|
favorite_director: profile.stats.favorite_director,
|
|
most_active_month: profile.stats.most_active_month,
|
|
},
|
|
following_count,
|
|
followers_count,
|
|
entries,
|
|
history,
|
|
trends,
|
|
})
|
|
.into_response()
|
|
}
|
|
|
|
#[utoipa::path(
|
|
get, path = "/api/v1/diary/export",
|
|
params(ExportQueryParams),
|
|
responses(
|
|
(status = 200, description = "Diary file download", content_type = "text/csv"),
|
|
(status = 400, description = "Invalid format parameter"),
|
|
(status = 401, description = "Unauthorized"),
|
|
),
|
|
security(("bearer_auth" = []))
|
|
)]
|
|
pub async fn export_diary(
|
|
State(state): State<AppState>,
|
|
user: AuthenticatedUser,
|
|
Query(params): Query<ExportQueryParams>,
|
|
) -> impl IntoResponse {
|
|
let format = match params.format.as_str() {
|
|
"csv" => ExportFormat::Csv,
|
|
"json" => ExportFormat::Json,
|
|
_ => return StatusCode::BAD_REQUEST.into_response(),
|
|
};
|
|
let (content_type, filename) = match &format {
|
|
ExportFormat::Csv => ("text/csv; charset=utf-8", "diary.csv"),
|
|
ExportFormat::Json => ("application/json", "diary.json"),
|
|
};
|
|
let cmd = ExportCommand {
|
|
user_id: user.0.value(),
|
|
format,
|
|
};
|
|
match export_diary_uc::execute(&state.app_ctx, cmd).await {
|
|
Ok(bytes) => (
|
|
StatusCode::OK,
|
|
[
|
|
(axum::http::header::CONTENT_TYPE, content_type.to_string()),
|
|
(
|
|
axum::http::header::CONTENT_DISPOSITION,
|
|
format!("attachment; filename=\"{}\"", filename),
|
|
),
|
|
],
|
|
bytes,
|
|
)
|
|
.into_response(),
|
|
Err(e) => {
|
|
tracing::error!("export error: {:?}", e);
|
|
StatusCode::INTERNAL_SERVER_ERROR.into_response()
|
|
}
|
|
}
|
|
}
|