Files
sorsfonalak/services/backend/src/routes/shares.rs
T

212 lines
7.7 KiB
Rust
Raw Normal View History

//! 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<Uuid>,
synastry_id: Option<Uuid>,
analysis_id: Option<Uuid>,
title: Option<String>,
show_birth_data: bool,
view_count: i64,
created_at: OffsetDateTime,
revoked_at: Option<OffsetDateTime>,
}
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<String>,
/// 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<CreateShare>,
) -> ApiResult<(StatusCode, Json<Value>)> {
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::<String>()).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<Json<Value>> {
let rows: Vec<ShareRow> =
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::<Vec<_>>() })))
}
pub async fn revoke(State(state): St, auth: AuthUser, WithRejection(Path(id), _): IdPath) -> ApiResult<StatusCode> {
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<Value, ApiError> {
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<String>) -> ApiResult<Json<Value>> {
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?))
}