//! Public sharing links. Creating and revoking a link needs login; opening //! one (`GET /v1/public/shares/{slug}`) does not. The public view never //! contains birth data unless the owner allowed it for their own chart. use axum::Json; use axum::extract::{Path, State}; use axum::http::StatusCode; use axum_extra::extract::WithRejection; use serde::Deserialize; use serde_json::{Value, json}; use sqlx::PgPool; use time::OffsetDateTime; use uuid::Uuid; use super::analyses::{can_see, find_analysis}; use super::charts::{ChartRow, find_chart, owned_chart}; use super::synastries::{VisibleSynastry, load_synastry, visible_synastry}; use super::{Body, IdPath, St}; use crate::auth::AuthUser; use crate::error::{ApiError, ApiResult}; use crate::views::{public_chart, rfc3339, rfc3339_opt}; #[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize)] #[serde(rename_all = "snake_case")] pub enum ShareKind { Chart, Synastry, Analysis, } #[derive(Debug, sqlx::FromRow)] struct ShareRow { id: Uuid, owner_id: Uuid, slug: String, kind: String, chart_id: Option, synastry_id: Option, analysis_id: Option, title: Option, show_birth_data: bool, view_count: i64, created_at: OffsetDateTime, revoked_at: Option, } const SHARE_COLUMNS: &str = "id, owner_id, slug, kind, chart_id, synastry_id, analysis_id, title, show_birth_data, \ view_count, created_at, revoked_at"; /// 96 random bits, 16 URL-safe characters. fn new_slug() -> String { db::random_token(12) } impl ShareRow { fn view(&self, base_url: &str) -> Value { json!({ "id": self.id, "slug": self.slug, "url": format!("{base_url}/s/{}", self.slug), "kind": self.kind, "chart_id": self.chart_id, "synastry_id": self.synastry_id, "analysis_id": self.analysis_id, "title": self.title, "show_birth_data": self.show_birth_data, "view_count": self.view_count, "created_at": rfc3339(self.created_at), "revoked_at": rfc3339_opt(self.revoked_at), }) } } #[derive(Deserialize)] #[serde(deny_unknown_fields)] pub struct CreateShare { kind: ShareKind, /// Id of the chart, synastry or analysis. target_id: Uuid, title: Option, /// Show birth date, time and place (only ever of the sharer's own charts). #[serde(default)] show_birth_data: bool, } pub async fn create( State(state): St, auth: AuthUser, WithRejection(Json(req), _): Body, ) -> ApiResult<(StatusCode, Json)> { let (chart_id, synastry_id, analysis_id, kind) = match req.kind { ShareKind::Chart => { owned_chart(&state.db, req.target_id, auth.id()).await?; (Some(req.target_id), None, None, "chart") } ShareKind::Synastry => { visible_synastry(&state.db, req.target_id, auth.id()).await?; (None, Some(req.target_id), None, "synastry") } ShareKind::Analysis => { let analysis = find_analysis(&state.db, req.target_id).await?.ok_or(ApiError::NotFound("analysis"))?; if !can_see(&state.db, &analysis, auth.id()).await? { return Err(ApiError::NotFound("analysis")); } if analysis.status != "done" { return Err(ApiError::conflict("analysis_not_ready", "only finished analyses can be shared")); } (None, None, Some(req.target_id), "analysis") } }; let title = req.title.map(|t| t.trim().chars().take(120).collect::()).filter(|t| !t.is_empty()); let row: ShareRow = sqlx::query_as(&format!( "INSERT INTO shares (id, owner_id, slug, kind, chart_id, synastry_id, analysis_id, title, show_birth_data) \ VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9) RETURNING {SHARE_COLUMNS}" )) .bind(Uuid::now_v7()) .bind(auth.id()) .bind(new_slug()) .bind(kind) .bind(chart_id) .bind(synastry_id) .bind(analysis_id) .bind(title) .bind(req.show_birth_data) .fetch_one(&state.db) .await?; Ok((StatusCode::CREATED, Json(row.view(&state.config.public_base_url)))) } pub async fn list(State(state): St, auth: AuthUser) -> ApiResult> { let rows: Vec = sqlx::query_as(&format!("SELECT {SHARE_COLUMNS} FROM shares WHERE owner_id = $1 ORDER BY created_at DESC")) .bind(auth.id()) .fetch_all(&state.db) .await?; let base = &state.config.public_base_url; Ok(Json(json!({ "shares": rows.iter().map(|r| r.view(base)).collect::>() }))) } pub async fn revoke(State(state): St, auth: AuthUser, WithRejection(Path(id), _): IdPath) -> ApiResult { let result = sqlx::query("UPDATE shares SET revoked_at = now() WHERE id = $1 AND owner_id = $2 AND revoked_at IS NULL") .bind(id) .bind(auth.id()) .execute(&state.db) .await?; if result.rows_affected() == 0 { return Err(ApiError::NotFound("share")); } Ok(StatusCode::NO_CONTENT) } // --- public view ------------------------------------------------------------------------------- fn public_chart_block(chart: &ChartRow, share: &ShareRow) -> Value { // Birth data only of the sharer's own chart, never of a partner's. let show = share.show_birth_data && chart.owner_id == share.owner_id; json!({ "label": chart.label, "chart": public_chart(&chart.result, show) }) } fn public_synastry_block(s: &VisibleSynastry, share: &ShareRow) -> Value { json!({ "chart1": public_chart_block(&s.chart1, share), "chart2": public_chart_block(&s.chart2, share), "synastry": s.synastry.result, }) } async fn public_body(db: &PgPool, share: &ShareRow) -> Result { let mut body = json!({ "kind": share.kind, "title": share.title, "created_at": rfc3339(share.created_at), }); if let Some(chart_id) = share.chart_id { let chart = find_chart(db, chart_id).await?.ok_or(ApiError::NotFound("share"))?; body["chart"] = public_chart_block(&chart, share); } else if let Some(synastry_id) = share.synastry_id { let s = load_synastry(db, synastry_id).await?.ok_or(ApiError::NotFound("share"))?; body["synastry"] = public_synastry_block(&s, share); } else if let Some(analysis_id) = share.analysis_id { let analysis = find_analysis(db, analysis_id).await?.ok_or(ApiError::NotFound("share"))?; body["analysis"] = json!({ "kind": analysis.kind, "language": analysis.language, "content": analysis.content, "completed_at": rfc3339_opt(analysis.completed_at), }); if let Some(chart_id) = analysis.chart_id { let chart = find_chart(db, chart_id).await?.ok_or(ApiError::NotFound("share"))?; body["chart"] = public_chart_block(&chart, share); } if let Some(synastry_id) = analysis.synastry_id { let s = load_synastry(db, synastry_id).await?.ok_or(ApiError::NotFound("share"))?; body["synastry"] = public_synastry_block(&s, share); } } Ok(body) } /// Public: the shared content for the share page and its OG image. pub async fn public_view(State(state): St, Path(slug): Path) -> ApiResult> { let share: ShareRow = sqlx::query_as(&format!( "UPDATE shares SET view_count = view_count + 1 WHERE slug = $1 AND revoked_at IS NULL RETURNING {SHARE_COLUMNS}" )) .bind(slug.trim()) .fetch_optional(&state.db) .await? .ok_or(ApiError::NotFound("share"))?; Ok(Json(public_body(&state.db, &share).await?)) }