Famous people: admin page, own prompt, one photo, public pages
- Admin "Híres emberek": birth data, one photo (S3: DigitalOcean Spaces in production, RustFS in development), a face point that every crop keeps in view, publishing, and a detailed portrait written with its own `celebrity` prompt (third person, by name, from the chart alone). - The photo is stored once (upright JPEG, at most 2000 px, no metadata); next/image makes the sizes from it, so Cloudflare can cache those. - Public list and pages (/hires-emberek), in the sitemap, with a share image showing the face and the chart. - Share images: the wheel's glyphs and numbers are drawn with the card's fonts (inside the SVG image they came out as boxes, on every card). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012vLHzh5qUhFtmJhzkcTbXL
This commit is contained in:
@@ -106,6 +106,12 @@ pub struct Config {
|
||||
/// `SIGNUP_MODE` (`invite` or `open`, default `invite`): whether new
|
||||
/// accounts need an invitation.
|
||||
pub signup_mode: SignupMode,
|
||||
/// Object storage of the uploaded photos (see [`crate::storage`]); `None`
|
||||
/// when `S3_ENDPOINT` is not set (photo uploads are then refused).
|
||||
pub storage: Option<crate::storage::StorageConfig>,
|
||||
/// `S3_CREATE_BUCKET` (default false): create the bucket at startup if it
|
||||
/// is missing (development; in production it is made in the console).
|
||||
pub storage_create_bucket: bool,
|
||||
}
|
||||
|
||||
/// `STRIPE_SECRET_KEY` (`sk_test_…` or `sk_live_…`), `STRIPE_WEBHOOK_SECRET`
|
||||
@@ -219,6 +225,18 @@ impl Config {
|
||||
Some("open") => SignupMode::Open,
|
||||
Some(other) => bail!("invalid SIGNUP_MODE '{other}': use 'invite' or 'open'"),
|
||||
},
|
||||
storage: match var("S3_ENDPOINT") {
|
||||
None => None,
|
||||
Some(endpoint) => Some(crate::storage::StorageConfig {
|
||||
endpoint: endpoint.trim_end_matches('/').to_string(),
|
||||
bucket: var("S3_BUCKET").context("S3_BUCKET is required with S3_ENDPOINT")?,
|
||||
region: var("S3_REGION").unwrap_or_else(|| "us-east-1".into()),
|
||||
access_key: var("S3_ACCESS_KEY_ID").context("S3_ACCESS_KEY_ID is required with S3_ENDPOINT")?,
|
||||
secret_key: var("S3_SECRET_ACCESS_KEY")
|
||||
.context("S3_SECRET_ACCESS_KEY is required with S3_ENDPOINT")?,
|
||||
}),
|
||||
},
|
||||
storage_create_bucket: parsed("S3_CREATE_BUCKET", false)?,
|
||||
};
|
||||
if config.session_ttl_days < 1 {
|
||||
bail!("SESSION_TTL_DAYS must be at least 1");
|
||||
@@ -260,6 +278,14 @@ impl Config {
|
||||
max_charts_per_user: 50,
|
||||
free_person_slots: 5,
|
||||
signup_mode: SignupMode::Open,
|
||||
storage: Some(crate::storage::StorageConfig {
|
||||
endpoint: format!("{horoscope_api_url}/s3"),
|
||||
bucket: "photos".into(),
|
||||
region: "us-east-1".into(),
|
||||
access_key: "test-key".into(),
|
||||
secret_key: "test-secret".into(),
|
||||
}),
|
||||
storage_create_bucket: false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -17,7 +17,9 @@ mod models;
|
||||
mod oidc;
|
||||
mod packages;
|
||||
mod persons;
|
||||
mod photo;
|
||||
mod routes;
|
||||
mod storage;
|
||||
mod stripe;
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
@@ -52,6 +54,8 @@ pub struct AppState {
|
||||
pub share_visits: LoginLimiter,
|
||||
pub models: models::Catalog,
|
||||
pub stripe: stripe::Client,
|
||||
/// Uploaded photos; `None` when no object storage is configured.
|
||||
pub storage: Option<storage::Storage>,
|
||||
}
|
||||
|
||||
impl AppState {
|
||||
@@ -66,6 +70,7 @@ impl AppState {
|
||||
share_visits: LoginLimiter::new(1, Duration::from_secs(30 * 60)),
|
||||
models: models::Catalog::new(&config.openrouter_models_url),
|
||||
stripe: stripe::Client::default(),
|
||||
storage: config.storage.clone().map(storage::Storage::new),
|
||||
db,
|
||||
config,
|
||||
}
|
||||
@@ -91,7 +96,14 @@ async fn main() -> anyhow::Result<()> {
|
||||
if std::env::args().nth(1).as_deref() == Some("recalculate") {
|
||||
return routes::recalculate(&AppState::new(pool, config)).await;
|
||||
}
|
||||
let app = routes::router(Arc::new(AppState::new(pool, config)));
|
||||
let state = AppState::new(pool, config);
|
||||
if state.config.storage_create_bucket
|
||||
&& let Some(storage) = &state.storage
|
||||
&& let Err(e) = storage.ensure_bucket().await
|
||||
{
|
||||
tracing::warn!(error = %e, "creating the object storage bucket failed");
|
||||
}
|
||||
let app = routes::router(Arc::new(state));
|
||||
let listener = tokio::net::TcpListener::bind(addr).await.with_context(|| format!("binding {addr}"))?;
|
||||
tracing::info!(%addr, "listening");
|
||||
axum::serve(listener, app).with_graceful_shutdown(service_kit::shutdown_signal()).await?;
|
||||
|
||||
@@ -47,7 +47,7 @@ impl Function {
|
||||
match kind {
|
||||
Kind::Summary => Function::Summary,
|
||||
Kind::Question => Function::Question,
|
||||
Kind::Natal | Kind::Synastry | Kind::Forecast => Function::Analysis,
|
||||
Kind::Natal | Kind::Synastry | Kind::Forecast | Kind::Celebrity => Function::Analysis,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,111 @@
|
||||
//! Uploaded photos: one stored version per photo, an upright JPEG at most
|
||||
//! [`MAX_SIDE`] pixels on its longer side. Sized versions are made on request
|
||||
//! by the frontend's image optimizer, so nothing else is stored.
|
||||
//!
|
||||
//! Re-encoding also drops the metadata of the original (EXIF: camera, place).
|
||||
|
||||
use std::io::Cursor;
|
||||
|
||||
use image::codecs::jpeg::JpegEncoder;
|
||||
use image::imageops::FilterType;
|
||||
use image::metadata::Orientation;
|
||||
use image::{DynamicImage, ImageDecoder, ImageFormat, ImageReader, Limits};
|
||||
|
||||
/// The longer side of the stored photo, in pixels.
|
||||
pub const MAX_SIDE: u32 = 2000;
|
||||
/// The largest upload accepted, in bytes.
|
||||
pub const MAX_UPLOAD: usize = 15 * 1024 * 1024;
|
||||
/// The smallest photo worth showing (shorter side, in pixels).
|
||||
const MIN_SIDE: u32 = 200;
|
||||
const QUALITY: u8 = 86;
|
||||
|
||||
pub struct Photo {
|
||||
pub jpeg: Vec<u8>,
|
||||
pub width: u32,
|
||||
pub height: u32,
|
||||
}
|
||||
|
||||
impl std::fmt::Debug for Photo {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
write!(f, "Photo({}×{}, {} bytes)", self.width, self.height, self.jpeg.len())
|
||||
}
|
||||
}
|
||||
|
||||
/// A JPEG, PNG or WebP image made upright, at most [`MAX_SIDE`] pixels, as JPEG.
|
||||
/// The error is a message for the uploader.
|
||||
pub fn normalize(bytes: &[u8]) -> Result<Photo, String> {
|
||||
let unreadable = || "A képet nem sikerült beolvasni. JPEG, PNG vagy WebP fotót tölts fel.".to_string();
|
||||
let mut reader = ImageReader::new(Cursor::new(bytes)).with_guessed_format().map_err(|_| unreadable())?;
|
||||
if !matches!(reader.format(), Some(ImageFormat::Jpeg | ImageFormat::Png | ImageFormat::WebP)) {
|
||||
return Err(unreadable());
|
||||
}
|
||||
let mut limits = Limits::default();
|
||||
limits.max_image_width = Some(12_000);
|
||||
limits.max_image_height = Some(12_000);
|
||||
reader.limits(limits);
|
||||
let mut decoder = reader.into_decoder().map_err(|_| unreadable())?;
|
||||
let orientation = decoder.orientation().unwrap_or(Orientation::NoTransforms);
|
||||
let mut img = DynamicImage::from_decoder(decoder).map_err(|_| unreadable())?;
|
||||
img.apply_orientation(orientation);
|
||||
if img.width().min(img.height()) < MIN_SIDE {
|
||||
return Err(format!("A kép túl kicsi: legalább {MIN_SIDE}×{MIN_SIDE} pixeles fotót tölts fel."));
|
||||
}
|
||||
if img.width().max(img.height()) > MAX_SIDE {
|
||||
img = img.resize(MAX_SIDE, MAX_SIDE, FilterType::Lanczos3);
|
||||
}
|
||||
// JPEG has no transparency: a transparent PNG gets the site's dark background.
|
||||
let rgb = flatten(img);
|
||||
let mut jpeg = Vec::new();
|
||||
JpegEncoder::new_with_quality(&mut jpeg, QUALITY).encode_image(&rgb).map_err(|e| e.to_string())?;
|
||||
Ok(Photo { jpeg, width: rgb.width(), height: rgb.height() })
|
||||
}
|
||||
|
||||
fn flatten(img: DynamicImage) -> image::RgbImage {
|
||||
if !img.color().has_alpha() {
|
||||
return img.to_rgb8();
|
||||
}
|
||||
let rgba = img.to_rgba8();
|
||||
let background = [13u16, 18, 32];
|
||||
image::RgbImage::from_fn(rgba.width(), rgba.height(), |x, y| {
|
||||
let [r, g, b, a] = rgba.get_pixel(x, y).0;
|
||||
let mix = |c: u8, bg: u16| ((u16::from(c) * u16::from(a) + bg * (255 - u16::from(a))) / 255) as u8;
|
||||
image::Rgb([mix(r, background[0]), mix(g, background[1]), mix(b, background[2])])
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn png(width: u32, height: u32, alpha: bool) -> Vec<u8> {
|
||||
let img = if alpha {
|
||||
DynamicImage::ImageRgba8(image::RgbaImage::from_pixel(width, height, image::Rgba([200, 100, 50, 0])))
|
||||
} else {
|
||||
DynamicImage::ImageRgb8(image::RgbImage::from_pixel(width, height, image::Rgb([200, 100, 50])))
|
||||
};
|
||||
let mut out = Vec::new();
|
||||
img.write_to(&mut Cursor::new(&mut out), ImageFormat::Png).unwrap();
|
||||
out
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn makes_a_bounded_jpeg() {
|
||||
let photo = normalize(&png(3000, 1500, false)).unwrap();
|
||||
assert_eq!((photo.width, photo.height), (2000, 1000));
|
||||
assert_eq!(&photo.jpeg[..3], &[0xFF, 0xD8, 0xFF], "a JPEG");
|
||||
let small = normalize(&png(400, 600, true)).unwrap();
|
||||
assert_eq!((small.width, small.height), (400, 600));
|
||||
// a fully transparent pixel takes the background colour
|
||||
let back = image::load_from_memory(&small.jpeg).unwrap().to_rgb8();
|
||||
let [r, g, b] = back.get_pixel(10, 10).0;
|
||||
assert!(r < 30 && g < 30 && b < 45, "{r} {g} {b}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_what_is_not_a_photo() {
|
||||
assert!(normalize(b"not an image at all").unwrap_err().contains("JPEG, PNG vagy WebP"));
|
||||
assert!(normalize(&png(150, 900, false)).unwrap_err().contains("túl kicsi"));
|
||||
// a GIF is a format we do not take
|
||||
assert!(normalize(b"GIF89a\x01\x00\x01\x00\x00\x00\x00;").is_err());
|
||||
}
|
||||
}
|
||||
@@ -165,11 +165,11 @@ pub async fn export(State(state): St, auth: AuthUser) -> ApiResult<impl IntoResp
|
||||
"last_login_at": rfc3339_opt(auth.user.last_login_at),
|
||||
"login_methods": rows("SELECT json_build_object('provider', provider, 'email', email, 'created_at', created_at, 'last_used_at', last_used_at) FROM auth_identities WHERE user_id = $1").await?,
|
||||
"sessions": rows("SELECT json_build_object('created_at', created_at, 'expires_at', expires_at, 'user_agent', user_agent) FROM sessions WHERE user_id = $1").await?,
|
||||
"charts": rows("SELECT json_build_object('id', id, 'label', label, 'is_primary', is_primary, 'birth_data', birth_data, 'result', result, 'created_at', created_at) FROM charts WHERE owner_id = $1").await?,
|
||||
"charts": rows("SELECT json_build_object('id', id, 'label', label, 'is_primary', is_primary, 'birth_data', birth_data, 'result', result, 'created_at', created_at) FROM charts WHERE owner_id = $1 AND kind <> 'celebrity'").await?,
|
||||
"synastries": rows("SELECT json_build_object('id', s.id, 'owner_id', s.owner_id, 'chart1_id', s.chart1_id, 'chart2_id', s.chart2_id, 'result', s.result, 'created_at', s.created_at) FROM synastries s JOIN charts c1 ON c1.id = s.chart1_id JOIN charts c2 ON c2.id = s.chart2_id WHERE s.owner_id = $1 OR c1.owner_id = $1 OR c2.owner_id = $1").await?,
|
||||
"invites": rows("SELECT json_build_object('id', id, 'chart_id', inviter_chart_id, 'message', message, 'created_at', created_at, 'expires_at', expires_at, 'accepted_at', accepted_at) FROM synastry_invites WHERE inviter_id = $1").await?,
|
||||
"forecasts": rows("SELECT json_build_object('id', f.id, 'chart_id', f.chart_id, 'year', f.year, 'location', f.location, 'result', f.result, 'created_at', f.created_at) FROM forecasts f JOIN charts c ON c.id = f.chart_id WHERE c.owner_id = $1").await?,
|
||||
"analyses": rows("SELECT json_build_object('id', a.id, 'kind', a.kind, 'chart_id', a.chart_id, 'synastry_id', a.synastry_id, 'forecast_id', a.forecast_id, 'language', a.language, 'status', a.status, 'content', a.content, 'created_at', a.created_at) FROM analyses a WHERE a.requested_by = $1 OR a.chart_id IN (SELECT id FROM charts WHERE owner_id = $1)").await?,
|
||||
"analyses": rows("SELECT json_build_object('id', a.id, 'kind', a.kind, 'chart_id', a.chart_id, 'synastry_id', a.synastry_id, 'forecast_id', a.forecast_id, 'language', a.language, 'status', a.status, 'content', a.content, 'created_at', a.created_at) FROM analyses a WHERE a.kind <> 'celebrity' AND (a.requested_by = $1 OR a.chart_id IN (SELECT id FROM charts WHERE owner_id = $1 AND kind <> 'celebrity'))").await?,
|
||||
"questions": rows("SELECT json_build_object('id', q.id, 'analysis_id', q.analysis_id, 'question', q.question, 'status', q.status, 'answer', q.answer, 'created_at', q.created_at) FROM questions q WHERE q.asked_by = $1").await?,
|
||||
"credit_ledger": rows("SELECT json_build_object('unit', unit, 'delta', delta, 'reason', reason, 'note', note, 'created_at', created_at) FROM credit_ledger WHERE user_id = $1 ORDER BY created_at").await?,
|
||||
"shares": rows("SELECT json_build_object('slug', slug, 'kind', kind, 'title', title, 'show_birth_data', show_birth_data, 'view_count', view_count, 'created_at', created_at, 'revoked_at', revoked_at) FROM shares WHERE owner_id = $1").await?,
|
||||
@@ -196,6 +196,31 @@ pub async fn delete_me(
|
||||
return Err(ApiError::BadRequest("set confirm to \"DELETE\" to delete the account".into()));
|
||||
}
|
||||
let mut tx = state.db.begin().await?;
|
||||
// Famous people's charts are the site's, not the admin's: another admin
|
||||
// takes them over, or the account cannot be deleted yet.
|
||||
let celebrities: i64 = sqlx::query_scalar("SELECT count(*) FROM charts WHERE owner_id = $1 AND kind = 'celebrity'")
|
||||
.bind(auth.id())
|
||||
.fetch_one(&mut *tx)
|
||||
.await?;
|
||||
if celebrities > 0 {
|
||||
let heir: Option<Uuid> = sqlx::query_scalar(
|
||||
"SELECT id FROM users WHERE id <> $1 AND 'admin' = ANY(roles) ORDER BY created_at LIMIT 1",
|
||||
)
|
||||
.bind(auth.id())
|
||||
.fetch_optional(&mut *tx)
|
||||
.await?;
|
||||
let Some(heir) = heir else {
|
||||
return Err(ApiError::conflict(
|
||||
"owns_celebrities",
|
||||
"A fiókhoz híres emberek tartoznak, és nincs másik admin, aki átvenné őket. Előbb töröld őket.",
|
||||
));
|
||||
};
|
||||
sqlx::query("UPDATE charts SET owner_id = $2 WHERE owner_id = $1 AND kind = 'celebrity'")
|
||||
.bind(auth.id())
|
||||
.bind(heir)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
}
|
||||
// Tarot readings belong to no chart: they go with the account.
|
||||
sqlx::query("DELETE FROM analyses WHERE kind = 'tarot' AND requested_by = $1")
|
||||
.bind(auth.id())
|
||||
|
||||
@@ -50,7 +50,7 @@ pub async fn list_users(
|
||||
);
|
||||
let rows: Vec<Row> = sqlx::query_as(
|
||||
"SELECT u.id, u.email, u.display_name, u.roles, u.email_verified_at IS NOT NULL, u.created_at, u.last_login_at, \
|
||||
(SELECT count(*) FROM charts c WHERE c.owner_id = u.id), \
|
||||
(SELECT count(*) FROM charts c WHERE c.owner_id = u.id AND c.kind <> 'celebrity'), \
|
||||
(SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger l WHERE l.user_id = u.id AND l.unit = 'natal'), \
|
||||
(SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger l WHERE l.user_id = u.id AND l.unit = 'synastry'), \
|
||||
(SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger l WHERE l.user_id = u.id AND l.unit = 'forecast'), \
|
||||
|
||||
@@ -55,7 +55,7 @@ pub struct AnalysisRow {
|
||||
pub requested_at: OffsetDateTime,
|
||||
}
|
||||
|
||||
const ANALYSIS_COLUMNS: &str = "id, kind, chart_id, synastry_id, forecast_id, language, prompt_version, status, \
|
||||
pub(super) const ANALYSIS_COLUMNS: &str = "id, kind, chart_id, synastry_id, forecast_id, language, prompt_version, status, \
|
||||
content, error, \
|
||||
credits_charged, created_at, completed_at, attempts, next_attempt_at, requested_at";
|
||||
|
||||
@@ -122,10 +122,27 @@ fn optional_body(body: &[u8]) -> Result<AnalysisRequest, ApiError> {
|
||||
}
|
||||
|
||||
pub(super) enum Target {
|
||||
Natal { chart_id: Uuid, hash: String },
|
||||
Summary { chart_id: Uuid, hash: String },
|
||||
Synastry { synastry_id: Uuid, hash: String },
|
||||
Forecast { forecast_id: Uuid, hash: String },
|
||||
Natal {
|
||||
chart_id: Uuid,
|
||||
hash: String,
|
||||
},
|
||||
Summary {
|
||||
chart_id: Uuid,
|
||||
hash: String,
|
||||
},
|
||||
Synastry {
|
||||
synastry_id: Uuid,
|
||||
hash: String,
|
||||
},
|
||||
Forecast {
|
||||
forecast_id: Uuid,
|
||||
hash: String,
|
||||
},
|
||||
/// A famous person's chart (admins only, no unit is spent).
|
||||
Celebrity {
|
||||
chart_id: Uuid,
|
||||
hash: String,
|
||||
},
|
||||
}
|
||||
|
||||
async fn request(
|
||||
@@ -179,6 +196,7 @@ pub(super) async fn queue(
|
||||
Target::Summary { chart_id, hash } => ("summary", hash, Some(*chart_id), None, None),
|
||||
Target::Synastry { synastry_id, hash } => ("synastry", hash, None, Some(*synastry_id), None),
|
||||
Target::Forecast { forecast_id, hash } => ("forecast", hash, None, None, Some(*forecast_id)),
|
||||
Target::Celebrity { chart_id, hash } => ("celebrity", hash, Some(*chart_id), None, None),
|
||||
};
|
||||
let (model, fallback) = &crate::models::models_for(state, Kind::parse(kind).expect("known kind")).await?;
|
||||
let (cache_key, prompt_version) = &versions(state, kind, hash, model, language).await?;
|
||||
@@ -212,15 +230,20 @@ pub(super) async fn queue(
|
||||
);
|
||||
let id = Uuid::now_v7();
|
||||
|
||||
// The same chart elsewhere (another user, same birth data) was already analysed: copy it.
|
||||
let cached: Option<(Value, Option<i32>, Option<i32>)> = sqlx::query_as(
|
||||
"SELECT content, input_tokens, output_tokens FROM analyses \
|
||||
WHERE cache_key = $1 AND prompt_version = $2 AND status = 'done' LIMIT 1",
|
||||
)
|
||||
.bind(cache_key)
|
||||
.bind(prompt_version)
|
||||
.fetch_optional(&mut *tx)
|
||||
.await?;
|
||||
// The same chart elsewhere (another user, same birth data) was already
|
||||
// analysed: copy it. Not a famous person's portrait: it has their name in it.
|
||||
let cached: Option<(Value, Option<i32>, Option<i32>)> = if kind == "celebrity" {
|
||||
None
|
||||
} else {
|
||||
sqlx::query_as(
|
||||
"SELECT content, input_tokens, output_tokens FROM analyses \
|
||||
WHERE cache_key = $1 AND prompt_version = $2 AND status = 'done' LIMIT 1",
|
||||
)
|
||||
.bind(cache_key)
|
||||
.bind(prompt_version)
|
||||
.fetch_optional(&mut *tx)
|
||||
.await?
|
||||
};
|
||||
if let Some((content, input_tokens, output_tokens)) = cached {
|
||||
let row: AnalysisRow = sqlx::query_as(&insert)
|
||||
.bind(id)
|
||||
|
||||
@@ -0,0 +1,546 @@
|
||||
//! Famous people: admins add them (birth data, one photo) and get a detailed
|
||||
//! analysis written about them in the third person (`celebrity` kind, its own
|
||||
//! prompt). Published ones have a public page (`/hires-emberek/<slug>`) with
|
||||
//! the birth data, the chart, the analysis and the photo; drafts only admins see.
|
||||
//!
|
||||
//! The photo is stored once (see [`crate::photo`]) under a new key at every
|
||||
//! upload and served by [`photo`], so the frontend's image optimizer and the
|
||||
//! CDN may keep it forever.
|
||||
|
||||
use axum::Json;
|
||||
use axum::body::Bytes;
|
||||
use axum::extract::{Path, State};
|
||||
use axum::http::{StatusCode, header};
|
||||
use axum::response::{IntoResponse, Response};
|
||||
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::{ANALYSIS_COLUMNS, AnalysisRow, Target, queue};
|
||||
use super::charts::{CHART_COLUMNS, ChartRow, calculate, find_chart};
|
||||
use super::{Body, IdPath, St, double_option};
|
||||
use crate::AppState;
|
||||
use crate::auth::{AdminUser, AuthUser};
|
||||
use crate::error::{ApiError, ApiResult};
|
||||
use crate::views::{chart_highlights, public_chart, rfc3339, rfc3339_opt};
|
||||
|
||||
/// The analyses of famous people are written in Hungarian (the public pages are).
|
||||
const LANGUAGE: &str = "hu";
|
||||
|
||||
#[derive(Debug, sqlx::FromRow)]
|
||||
struct CelebrityRow {
|
||||
id: Uuid,
|
||||
chart_id: Uuid,
|
||||
name: String,
|
||||
subtitle: Option<String>,
|
||||
slug: String,
|
||||
photo_key: Option<String>,
|
||||
photo_width: Option<i32>,
|
||||
photo_height: Option<i32>,
|
||||
focus_x: f32,
|
||||
focus_y: f32,
|
||||
published_at: Option<OffsetDateTime>,
|
||||
created_at: OffsetDateTime,
|
||||
updated_at: OffsetDateTime,
|
||||
}
|
||||
|
||||
const COLUMNS: &str = "id, chart_id, name, subtitle, slug, photo_key, photo_width, photo_height, focus_x, focus_y, \
|
||||
published_at, created_at, updated_at";
|
||||
|
||||
impl CelebrityRow {
|
||||
fn photo(&self) -> Value {
|
||||
match (&self.photo_key, self.photo_width, self.photo_height) {
|
||||
(Some(key), Some(width), Some(height)) => json!({
|
||||
"key": key, "width": width, "height": height, "focus_x": self.focus_x, "focus_y": self.focus_y,
|
||||
}),
|
||||
_ => Value::Null,
|
||||
}
|
||||
}
|
||||
|
||||
fn base(&self) -> Value {
|
||||
json!({
|
||||
"id": self.id,
|
||||
"name": self.name,
|
||||
"subtitle": self.subtitle,
|
||||
"slug": self.slug,
|
||||
"published": self.published_at.is_some(),
|
||||
"published_at": rfc3339_opt(self.published_at),
|
||||
"photo": self.photo(),
|
||||
"created_at": rfc3339(self.created_at),
|
||||
"updated_at": rfc3339(self.updated_at),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
async fn find(db: &PgPool, id: Uuid) -> Result<CelebrityRow, ApiError> {
|
||||
sqlx::query_as(&format!("SELECT {COLUMNS} FROM celebrities WHERE id = $1"))
|
||||
.bind(id)
|
||||
.fetch_optional(db)
|
||||
.await?
|
||||
.ok_or(ApiError::NotFound("celebrity"))
|
||||
}
|
||||
|
||||
/// The newest analysis of the famous person's chart (any state).
|
||||
async fn latest_analysis(db: &PgPool, chart_id: Uuid) -> Result<Option<AnalysisRow>, sqlx::Error> {
|
||||
sqlx::query_as(&format!(
|
||||
"SELECT {ANALYSIS_COLUMNS} FROM analyses WHERE chart_id = $1 AND kind = 'celebrity' \
|
||||
ORDER BY created_at DESC LIMIT 1"
|
||||
))
|
||||
.bind(chart_id)
|
||||
.fetch_optional(db)
|
||||
.await
|
||||
}
|
||||
|
||||
/// "Marilyn Monroe" → "marilyn-monroe"; "Kovács Ödön" → "kovacs-odon".
|
||||
fn slugify(name: &str) -> String {
|
||||
let ascii = deunicode::deunicode(name).to_lowercase();
|
||||
let mut slug = String::new();
|
||||
for c in ascii.chars() {
|
||||
if c.is_ascii_alphanumeric() {
|
||||
slug.push(c);
|
||||
} else if !slug.is_empty() && !slug.ends_with('-') {
|
||||
slug.push('-');
|
||||
}
|
||||
}
|
||||
let slug = slug.trim_end_matches('-').chars().take(80).collect::<String>();
|
||||
let slug = slug.trim_end_matches('-').to_string();
|
||||
if slug.is_empty() { "hires-ember".into() } else { slug }
|
||||
}
|
||||
|
||||
fn valid_slug(slug: &str) -> bool {
|
||||
!slug.is_empty()
|
||||
&& slug.len() <= 80
|
||||
&& slug
|
||||
.split('-')
|
||||
.all(|part| !part.is_empty() && part.bytes().all(|b| b.is_ascii_lowercase() || b.is_ascii_digit()))
|
||||
}
|
||||
|
||||
/// `base`, or `base-2`, `base-3`, ... whichever is free (`except`: the row being renamed).
|
||||
async fn free_slug(db: &PgPool, base: &str, except: Option<Uuid>) -> Result<String, sqlx::Error> {
|
||||
for n in 1..1000 {
|
||||
let slug = if n == 1 { base.to_string() } else { format!("{base}-{n}") };
|
||||
let taken: bool =
|
||||
sqlx::query_scalar("SELECT EXISTS (SELECT 1 FROM celebrities WHERE slug = $1 AND id IS DISTINCT FROM $2)")
|
||||
.bind(&slug)
|
||||
.bind(except)
|
||||
.fetch_one(db)
|
||||
.await?;
|
||||
if !taken {
|
||||
return Ok(slug);
|
||||
}
|
||||
}
|
||||
Ok(format!("{base}-{}", Uuid::now_v7().simple()))
|
||||
}
|
||||
|
||||
fn clean_name(name: &str) -> Result<String, ApiError> {
|
||||
let name: String = name.split_whitespace().collect::<Vec<_>>().join(" ").chars().take(100).collect();
|
||||
if name.is_empty() { Err(ApiError::BadRequest("A név nem lehet üres.".into())) } else { Ok(name) }
|
||||
}
|
||||
|
||||
fn clean_subtitle(subtitle: Option<&str>) -> Option<String> {
|
||||
subtitle.map(|s| s.trim().chars().take(160).collect::<String>()).filter(|s| !s.is_empty())
|
||||
}
|
||||
|
||||
/// Calculates the chart from birth data (the horoscope service never sees the name).
|
||||
async fn chart_for(state: &AppState, birth: Value) -> Result<(Value, Value, String), ApiError> {
|
||||
calculate(state, birth).await
|
||||
}
|
||||
|
||||
/// Queues the analysis of the chart (no unit is spent); an existing one with
|
||||
/// the same cache key is returned instead.
|
||||
async fn queue_analysis(state: &AppState, admin: &AuthUser, chart: &ChartRow) -> Result<AnalysisRow, ApiError> {
|
||||
let target = Target::Celebrity { chart_id: chart.id, hash: chart.chart_hash.clone() };
|
||||
Ok(queue(state, admin.id(), &target, LANGUAGE, None).await?.1)
|
||||
}
|
||||
|
||||
/// The admin view: everything, with the birth data for the edit form.
|
||||
async fn admin_view(db: &PgPool, row: &CelebrityRow) -> Result<Value, ApiError> {
|
||||
let chart = find_chart(db, row.chart_id).await?.ok_or(ApiError::NotFound("celebrity"))?;
|
||||
let analysis = latest_analysis(db, row.chart_id).await?;
|
||||
let mut view = row.base();
|
||||
view["birth_data"] = chart.birth_data.clone();
|
||||
view["birth"] = public_chart(&chart.result, true)["birth"].clone();
|
||||
view["highlights"] = chart_highlights(&chart.result);
|
||||
view["chart"] = chart.result.clone();
|
||||
view["analysis"] = analysis.map_or(Value::Null, |a| a.view());
|
||||
Ok(view)
|
||||
}
|
||||
|
||||
// --- admin -------------------------------------------------------------------------------------
|
||||
|
||||
type ListRow =
|
||||
(Uuid, Uuid, String, Option<String>, String, Option<OffsetDateTime>, Option<String>, Value, Option<String>);
|
||||
|
||||
pub async fn list(State(state): St, _admin: AdminUser) -> ApiResult<Json<Value>> {
|
||||
let rows: Vec<ListRow> = sqlx::query_as(
|
||||
"SELECT c.id, c.chart_id, c.name, c.subtitle, c.slug, c.published_at, c.photo_key, ch.result, \
|
||||
(SELECT a.status FROM analyses a WHERE a.chart_id = c.chart_id AND a.kind = 'celebrity' \
|
||||
ORDER BY a.created_at DESC LIMIT 1) \
|
||||
FROM celebrities c JOIN charts ch ON ch.id = c.chart_id ORDER BY c.created_at DESC",
|
||||
)
|
||||
.fetch_all(&state.db)
|
||||
.await?;
|
||||
let items: Vec<Value> = rows
|
||||
.into_iter()
|
||||
.map(|(id, chart_id, name, subtitle, slug, published_at, photo_key, result, status)| {
|
||||
json!({
|
||||
"id": id, "chart_id": chart_id, "name": name, "subtitle": subtitle, "slug": slug,
|
||||
"published": published_at.is_some(), "has_photo": photo_key.is_some(),
|
||||
"birth": public_chart(&result, true)["birth"].clone(),
|
||||
"highlights": chart_highlights(&result),
|
||||
"analysis_status": status,
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
Ok(Json(json!({ "celebrities": items })))
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct CreateCelebrity {
|
||||
name: String,
|
||||
subtitle: Option<String>,
|
||||
/// Birth data as for a chart (`POST /v1/charts`).
|
||||
birth: Value,
|
||||
}
|
||||
|
||||
/// Adds a famous person: calculates the chart and queues the analysis.
|
||||
pub async fn create(
|
||||
State(state): St,
|
||||
AdminUser(admin): AdminUser,
|
||||
WithRejection(Json(req), _): Body<CreateCelebrity>,
|
||||
) -> ApiResult<(StatusCode, Json<Value>)> {
|
||||
let name = clean_name(&req.name)?;
|
||||
let (birth, result, hash) = chart_for(&state, req.birth).await?;
|
||||
let slug = free_slug(&state.db, &slugify(&name), None).await?;
|
||||
let mut tx = state.db.begin().await?;
|
||||
let chart: ChartRow = sqlx::query_as(&format!(
|
||||
"INSERT INTO charts (id, owner_id, label, is_primary, kind, birth_data, result, chart_hash) \
|
||||
VALUES ($1, $2, $3, false, 'celebrity', $4, $5, $6) RETURNING {CHART_COLUMNS}"
|
||||
))
|
||||
.bind(Uuid::now_v7())
|
||||
.bind(admin.id())
|
||||
.bind(&name)
|
||||
.bind(birth)
|
||||
.bind(result)
|
||||
.bind(hash)
|
||||
.fetch_one(&mut *tx)
|
||||
.await?;
|
||||
let row: CelebrityRow = sqlx::query_as(&format!(
|
||||
"INSERT INTO celebrities (id, chart_id, name, subtitle, slug, created_by) \
|
||||
VALUES ($1, $2, $3, $4, $5, $6) RETURNING {COLUMNS}"
|
||||
))
|
||||
.bind(Uuid::now_v7())
|
||||
.bind(chart.id)
|
||||
.bind(&name)
|
||||
.bind(clean_subtitle(req.subtitle.as_deref()))
|
||||
.bind(&slug)
|
||||
.bind(admin.id())
|
||||
.fetch_one(&mut *tx)
|
||||
.await?;
|
||||
tx.commit().await?;
|
||||
queue_analysis(&state, &admin, &chart).await?;
|
||||
tracing::info!(admin = %admin.id(), celebrity = %row.id, "famous person added");
|
||||
Ok((StatusCode::CREATED, Json(admin_view(&state.db, &row).await?)))
|
||||
}
|
||||
|
||||
pub async fn get_one(
|
||||
State(state): St,
|
||||
_admin: AdminUser,
|
||||
WithRejection(Path(id), _): IdPath,
|
||||
) -> ApiResult<Json<Value>> {
|
||||
let row = find(&state.db, id).await?;
|
||||
Ok(Json(admin_view(&state.db, &row).await?))
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct UpdateCelebrity {
|
||||
name: Option<String>,
|
||||
#[serde(default, deserialize_with = "double_option")]
|
||||
subtitle: Option<Option<String>>,
|
||||
slug: Option<String>,
|
||||
published: Option<bool>,
|
||||
focus_x: Option<f32>,
|
||||
focus_y: Option<f32>,
|
||||
/// Corrected birth data: the chart is calculated again and, if it changed,
|
||||
/// the analysis is written again.
|
||||
birth: Option<Value>,
|
||||
}
|
||||
|
||||
pub async fn update(
|
||||
State(state): St,
|
||||
AdminUser(admin): AdminUser,
|
||||
WithRejection(Path(id), _): IdPath,
|
||||
WithRejection(Json(req), _): Body<UpdateCelebrity>,
|
||||
) -> ApiResult<Json<Value>> {
|
||||
let row = find(&state.db, id).await?;
|
||||
let name = req.name.as_deref().map(clean_name).transpose()?.unwrap_or_else(|| row.name.clone());
|
||||
let subtitle = match &req.subtitle {
|
||||
Some(s) => clean_subtitle(s.as_deref()),
|
||||
None => row.subtitle.clone(),
|
||||
};
|
||||
let slug = match req.slug.as_deref().map(str::trim) {
|
||||
Some(s) if s != row.slug => {
|
||||
if !valid_slug(s) {
|
||||
return Err(ApiError::BadRequest(
|
||||
"A cím csak kisbetűt, számot és kötőjelet tartalmazhat (pl. marilyn-monroe).".into(),
|
||||
));
|
||||
}
|
||||
if free_slug(&state.db, s, Some(id)).await? != s {
|
||||
return Err(ApiError::conflict("slug_taken", "Ez a cím már foglalt."));
|
||||
}
|
||||
s.to_string()
|
||||
}
|
||||
_ => row.slug.clone(),
|
||||
};
|
||||
let unit =
|
||||
|v: Option<f32>, current: f32| v.map_or(current, |v| if v.is_finite() { v.clamp(0.0, 1.0) } else { current });
|
||||
let (focus_x, focus_y) = (unit(req.focus_x, row.focus_x), unit(req.focus_y, row.focus_y));
|
||||
let published_at = match req.published {
|
||||
Some(true) => row.published_at.or(Some(OffsetDateTime::now_utc())),
|
||||
Some(false) => None,
|
||||
None => row.published_at,
|
||||
};
|
||||
|
||||
let chart = find_chart(&state.db, row.chart_id).await?.ok_or(ApiError::NotFound("celebrity"))?;
|
||||
let birth = req.birth.filter(|b| *b != chart.birth_data);
|
||||
let recalculated = match birth {
|
||||
Some(birth) => Some(chart_for(&state, birth).await?),
|
||||
None => None,
|
||||
};
|
||||
let chart_changed = recalculated.as_ref().is_some_and(|(_, _, hash)| *hash != chart.chart_hash);
|
||||
|
||||
let mut tx = state.db.begin().await?;
|
||||
if let Some((birth, result, hash)) = &recalculated {
|
||||
if chart_changed {
|
||||
// The analysis was written from the old chart.
|
||||
sqlx::query("DELETE FROM analyses WHERE chart_id = $1").bind(chart.id).execute(&mut *tx).await?;
|
||||
}
|
||||
sqlx::query(
|
||||
"UPDATE charts SET birth_data = $1, result = $2, chart_hash = $3, updated_at = now() WHERE id = $4",
|
||||
)
|
||||
.bind(birth)
|
||||
.bind(result)
|
||||
.bind(hash)
|
||||
.bind(chart.id)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
}
|
||||
sqlx::query("UPDATE charts SET label = $1 WHERE id = $2").bind(&name).bind(chart.id).execute(&mut *tx).await?;
|
||||
let row: CelebrityRow = sqlx::query_as(&format!(
|
||||
"UPDATE celebrities SET name = $2, subtitle = $3, slug = $4, focus_x = $5, focus_y = $6, published_at = $7, \
|
||||
updated_at = now() WHERE id = $1 RETURNING {COLUMNS}"
|
||||
))
|
||||
.bind(id)
|
||||
.bind(&name)
|
||||
.bind(&subtitle)
|
||||
.bind(&slug)
|
||||
.bind(focus_x)
|
||||
.bind(focus_y)
|
||||
.bind(published_at)
|
||||
.fetch_one(&mut *tx)
|
||||
.await?;
|
||||
tx.commit().await?;
|
||||
if chart_changed {
|
||||
let chart = find_chart(&state.db, row.chart_id).await?.ok_or(ApiError::NotFound("celebrity"))?;
|
||||
queue_analysis(&state, &admin, &chart).await?;
|
||||
}
|
||||
Ok(Json(admin_view(&state.db, &row).await?))
|
||||
}
|
||||
|
||||
/// Queues the analysis again when there is none or the last one failed
|
||||
/// (rewriting a finished one: `POST /v1/admin/analyses/{id}/regenerate`).
|
||||
pub async fn request_analysis(
|
||||
State(state): St,
|
||||
AdminUser(admin): AdminUser,
|
||||
WithRejection(Path(id), _): IdPath,
|
||||
) -> ApiResult<Json<Value>> {
|
||||
let row = find(&state.db, id).await?;
|
||||
let chart = find_chart(&state.db, row.chart_id).await?.ok_or(ApiError::NotFound("celebrity"))?;
|
||||
queue_analysis(&state, &admin, &chart).await?;
|
||||
Ok(Json(admin_view(&state.db, &row).await?))
|
||||
}
|
||||
|
||||
fn storage(state: &AppState) -> Result<&crate::storage::Storage, ApiError> {
|
||||
state
|
||||
.storage
|
||||
.as_ref()
|
||||
.ok_or_else(|| ApiError::conflict("storage_not_configured", "A fotótárolás nincs beállítva (S3_ENDPOINT)."))
|
||||
}
|
||||
|
||||
/// Deletes a stored photo; a failure is only logged (the row no longer points to it).
|
||||
async fn delete_photo(state: &AppState, key: &str) {
|
||||
if let Some(storage) = &state.storage
|
||||
&& let Err(e) = storage.delete(key).await
|
||||
{
|
||||
tracing::warn!(key, error = %e, "deleting a photo from the object storage failed");
|
||||
}
|
||||
}
|
||||
|
||||
/// Uploads the photo (the request body is the image itself: JPEG, PNG or
|
||||
/// WebP); it replaces the previous one. The face point is reset.
|
||||
pub async fn upload_photo(
|
||||
State(state): St,
|
||||
AdminUser(admin): AdminUser,
|
||||
WithRejection(Path(id), _): IdPath,
|
||||
body: Bytes,
|
||||
) -> ApiResult<Json<Value>> {
|
||||
let row = find(&state.db, id).await?;
|
||||
let storage = storage(&state)?;
|
||||
if body.len() > crate::photo::MAX_UPLOAD {
|
||||
return Err(ApiError::BadRequest("A kép legfeljebb 15 MB lehet.".into()));
|
||||
}
|
||||
let photo = tokio::task::spawn_blocking(move || crate::photo::normalize(&body))
|
||||
.await
|
||||
.map_err(|e| ApiError::Internal(format!("photo processing: {e}")))?
|
||||
.map_err(ApiError::BadRequest)?;
|
||||
let key = format!("celebrities/{}/{}.jpg", row.id, db::random_token(9));
|
||||
storage
|
||||
.put(&key, photo.jpeg, "image/jpeg")
|
||||
.await
|
||||
.map_err(|e| ApiError::Internal(format!("storing the photo: {e}")))?;
|
||||
let updated: CelebrityRow = sqlx::query_as(&format!(
|
||||
"UPDATE celebrities SET photo_key = $2, photo_width = $3, photo_height = $4, focus_x = 0.5, focus_y = 0.3, \
|
||||
updated_at = now() WHERE id = $1 RETURNING {COLUMNS}"
|
||||
))
|
||||
.bind(id)
|
||||
.bind(&key)
|
||||
.bind(i32::try_from(photo.width).unwrap_or(i32::MAX))
|
||||
.bind(i32::try_from(photo.height).unwrap_or(i32::MAX))
|
||||
.fetch_one(&state.db)
|
||||
.await?;
|
||||
if let Some(old) = &row.photo_key {
|
||||
delete_photo(&state, old).await;
|
||||
}
|
||||
tracing::info!(admin = %admin.id(), celebrity = %id, width = photo.width, height = photo.height, "photo uploaded");
|
||||
Ok(Json(admin_view(&state.db, &updated).await?))
|
||||
}
|
||||
|
||||
pub async fn remove_photo(
|
||||
State(state): St,
|
||||
_admin: AdminUser,
|
||||
WithRejection(Path(id), _): IdPath,
|
||||
) -> ApiResult<Json<Value>> {
|
||||
let row = find(&state.db, id).await?;
|
||||
let updated: CelebrityRow = sqlx::query_as(&format!(
|
||||
"UPDATE celebrities SET photo_key = NULL, photo_width = NULL, photo_height = NULL, updated_at = now() \
|
||||
WHERE id = $1 RETURNING {COLUMNS}"
|
||||
))
|
||||
.bind(id)
|
||||
.fetch_one(&state.db)
|
||||
.await?;
|
||||
if let Some(old) = &row.photo_key {
|
||||
delete_photo(&state, old).await;
|
||||
}
|
||||
Ok(Json(admin_view(&state.db, &updated).await?))
|
||||
}
|
||||
|
||||
/// Deletes the famous person with their chart, analysis and photo.
|
||||
pub async fn remove(
|
||||
State(state): St,
|
||||
AdminUser(admin): AdminUser,
|
||||
WithRejection(Path(id), _): IdPath,
|
||||
) -> ApiResult<StatusCode> {
|
||||
let row = find(&state.db, id).await?;
|
||||
sqlx::query("DELETE FROM charts WHERE id = $1").bind(row.chart_id).execute(&state.db).await?;
|
||||
if let Some(key) = &row.photo_key {
|
||||
delete_photo(&state, key).await;
|
||||
}
|
||||
tracing::info!(admin = %admin.id(), celebrity = %id, "famous person deleted");
|
||||
Ok(StatusCode::NO_CONTENT)
|
||||
}
|
||||
|
||||
// --- public ------------------------------------------------------------------------------------
|
||||
|
||||
/// Public: the published famous people, newest first.
|
||||
pub async fn public_list(State(state): St) -> ApiResult<Json<Value>> {
|
||||
let rows: Vec<CelebrityRow> = sqlx::query_as(&format!(
|
||||
"SELECT {COLUMNS} FROM celebrities WHERE published_at IS NOT NULL ORDER BY published_at DESC"
|
||||
))
|
||||
.fetch_all(&state.db)
|
||||
.await?;
|
||||
let mut items = Vec::with_capacity(rows.len());
|
||||
for row in &rows {
|
||||
let chart = find_chart(&state.db, row.chart_id).await?.ok_or(ApiError::NotFound("celebrity"))?;
|
||||
let mut item = row.base();
|
||||
item["birth"] = public_chart(&chart.result, true)["birth"].clone();
|
||||
item["highlights"] = chart_highlights(&chart.result);
|
||||
items.push(item);
|
||||
}
|
||||
Ok(Json(json!({ "celebrities": items })))
|
||||
}
|
||||
|
||||
/// Public: one famous person's page (a draft only for admins).
|
||||
pub async fn public_view(
|
||||
State(state): St,
|
||||
auth: Result<AuthUser, ApiError>,
|
||||
Path(slug): Path<String>,
|
||||
) -> ApiResult<Json<Value>> {
|
||||
let row: CelebrityRow = sqlx::query_as(&format!("SELECT {COLUMNS} FROM celebrities WHERE slug = $1"))
|
||||
.bind(slug.trim())
|
||||
.fetch_optional(&state.db)
|
||||
.await?
|
||||
.ok_or(ApiError::NotFound("celebrity"))?;
|
||||
let admin = auth.is_ok_and(|a| a.user.has_role(db::Role::Admin));
|
||||
if row.published_at.is_none() && !admin {
|
||||
return Err(ApiError::NotFound("celebrity"));
|
||||
}
|
||||
let chart = find_chart(&state.db, row.chart_id).await?.ok_or(ApiError::NotFound("celebrity"))?;
|
||||
let analysis = latest_analysis(&state.db, row.chart_id).await?.filter(|a| a.status == "done");
|
||||
let mut view = row.base();
|
||||
view["chart"] = public_chart(&chart.result, true);
|
||||
view["analysis"] = match analysis {
|
||||
Some(a) => json!({
|
||||
"id": a.id,
|
||||
"language": a.language,
|
||||
"content": a.content,
|
||||
"completed_at": rfc3339_opt(a.completed_at),
|
||||
}),
|
||||
None => Value::Null,
|
||||
};
|
||||
Ok(Json(view))
|
||||
}
|
||||
|
||||
/// Public: a stored photo, only while a famous person uses it. The key changes
|
||||
/// with every upload, so it may be cached for good.
|
||||
pub async fn photo(State(state): St, Path(key): Path<String>) -> ApiResult<Response> {
|
||||
let used: bool = sqlx::query_scalar("SELECT EXISTS (SELECT 1 FROM celebrities WHERE photo_key = $1)")
|
||||
.bind(&key)
|
||||
.fetch_one(&state.db)
|
||||
.await?;
|
||||
if !used {
|
||||
return Err(ApiError::NotFound("photo"));
|
||||
}
|
||||
let object = storage(&state)?
|
||||
.get(&key)
|
||||
.await
|
||||
.map_err(|e| ApiError::Internal(format!("reading the photo: {e}")))?
|
||||
.ok_or(ApiError::NotFound("photo"))?;
|
||||
Ok((
|
||||
[
|
||||
(header::CONTENT_TYPE, object.content_type.unwrap_or_else(|| "image/jpeg".into())),
|
||||
(header::CACHE_CONTROL, "public, max-age=31536000, immutable".into()),
|
||||
],
|
||||
object.bytes,
|
||||
)
|
||||
.into_response())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn slugs() {
|
||||
assert_eq!(slugify("Marilyn Monroe"), "marilyn-monroe");
|
||||
assert_eq!(slugify(" Kovács Ödön (1911–1996) "), "kovacs-odon-1911-1996");
|
||||
assert_eq!(slugify("Szőke Szabolcs, Jr."), "szoke-szabolcs-jr");
|
||||
assert_eq!(slugify("!!!"), "hires-ember");
|
||||
assert!(valid_slug("marilyn-monroe") && valid_slug("a1"));
|
||||
assert!(!valid_slug("Marilyn") && !valid_slug("a--b") && !valid_slug("-a") && !valid_slug(""));
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,9 @@
|
||||
//! Natal charts of a user: their own chart (kind `own`; the current one is
|
||||
//! primary) and charts of other people they added (kind `person`, see
|
||||
//! [`crate::persons`]). Calculated by the horoscope service.
|
||||
//!
|
||||
//! Famous people's charts (kind `celebrity`) are kept by the admin pages
|
||||
//! (see `celebrities`): these routes neither list nor change them.
|
||||
|
||||
use axum::Json;
|
||||
use axum::extract::State;
|
||||
@@ -26,7 +29,7 @@ pub struct ChartRow {
|
||||
pub owner_id: Uuid,
|
||||
pub label: String,
|
||||
pub is_primary: bool,
|
||||
/// `own` or `person`.
|
||||
/// `own`, `person` or `celebrity`.
|
||||
pub kind: String,
|
||||
pub birth_data: Value,
|
||||
pub result: Value,
|
||||
@@ -83,9 +86,12 @@ pub async fn find_chart(db: impl PgExecutor<'_>, id: Uuid) -> Result<Option<Char
|
||||
Ok(sqlx::query_as(&format!("SELECT {CHART_COLUMNS} FROM charts WHERE id = $1")).bind(id).fetch_optional(db).await?)
|
||||
}
|
||||
|
||||
/// A chart of `owner`; 404 for missing charts and charts of others.
|
||||
/// A chart of `owner`; 404 for missing charts, charts of others and famous people's charts.
|
||||
pub async fn owned_chart(db: &PgPool, id: Uuid, owner: Uuid) -> Result<ChartRow, ApiError> {
|
||||
find_chart(db, id).await?.filter(|c| c.owner_id == owner).ok_or(ApiError::NotFound("chart"))
|
||||
find_chart(db, id)
|
||||
.await?
|
||||
.filter(|c| c.owner_id == owner && c.kind != "celebrity")
|
||||
.ok_or(ApiError::NotFound("chart"))
|
||||
}
|
||||
|
||||
pub async fn primary_chart(db: &PgPool, owner: Uuid) -> Result<Option<ChartRow>, ApiError> {
|
||||
@@ -102,7 +108,8 @@ fn clean_label(label: &str) -> Result<String, ApiError> {
|
||||
|
||||
pub async fn list(State(state): St, auth: AuthUser) -> ApiResult<Json<Value>> {
|
||||
let rows: Vec<ChartRow> = sqlx::query_as(&format!(
|
||||
"SELECT {CHART_COLUMNS} FROM charts WHERE owner_id = $1 ORDER BY is_primary DESC, created_at DESC"
|
||||
"SELECT {CHART_COLUMNS} FROM charts WHERE owner_id = $1 AND kind <> 'celebrity' \
|
||||
ORDER BY is_primary DESC, created_at DESC"
|
||||
))
|
||||
.bind(auth.id())
|
||||
.fetch_all(&state.db)
|
||||
@@ -190,8 +197,10 @@ pub async fn create(
|
||||
queue_summary(&state, &auth, &chart).await;
|
||||
return Ok((StatusCode::OK, Json(chart.owner_view())));
|
||||
}
|
||||
let (count,): (i64,) =
|
||||
sqlx::query_as("SELECT count(*) FROM charts WHERE owner_id = $1").bind(auth.id()).fetch_one(&state.db).await?;
|
||||
let (count,): (i64,) = sqlx::query_as("SELECT count(*) FROM charts WHERE owner_id = $1 AND kind <> 'celebrity'")
|
||||
.bind(auth.id())
|
||||
.fetch_one(&state.db)
|
||||
.await?;
|
||||
if count >= state.config.max_charts_per_user {
|
||||
return Err(ApiError::conflict(
|
||||
"chart_limit_reached",
|
||||
@@ -372,7 +381,7 @@ pub async fn remove(
|
||||
auth: AuthUser,
|
||||
WithRejection(axum::extract::Path(id), _): IdPath,
|
||||
) -> ApiResult<StatusCode> {
|
||||
let result = sqlx::query("DELETE FROM charts WHERE id = $1 AND owner_id = $2")
|
||||
let result = sqlx::query("DELETE FROM charts WHERE id = $1 AND owner_id = $2 AND kind <> 'celebrity'")
|
||||
.bind(id)
|
||||
.bind(auth.id())
|
||||
.execute(&state.db)
|
||||
|
||||
@@ -10,6 +10,7 @@ mod admin;
|
||||
mod analyses;
|
||||
mod auth;
|
||||
mod calculator;
|
||||
mod celebrities;
|
||||
mod charts;
|
||||
mod errors;
|
||||
mod forecasts;
|
||||
@@ -30,7 +31,7 @@ pub use recalculate::run as recalculate;
|
||||
|
||||
use std::sync::Arc;
|
||||
|
||||
use axum::extract::{Path, State};
|
||||
use axum::extract::{DefaultBodyLimit, Path, State};
|
||||
use axum::http::{HeaderValue, Method, header};
|
||||
use axum::routing::{delete, get, patch, post};
|
||||
use axum::{Json, Router};
|
||||
@@ -129,6 +130,9 @@ pub fn router(state: Arc<AppState>) -> Router {
|
||||
.route("/v1/public/chart", post(calculator::chart))
|
||||
.route("/v1/public/geo/countries", get(calculator::countries))
|
||||
.route("/v1/public/geo/places", get(calculator::places))
|
||||
.route("/v1/public/celebrities", get(celebrities::public_list))
|
||||
.route("/v1/public/celebrities/{slug}", get(celebrities::public_view))
|
||||
.route("/v1/public/photos/{*key}", get(celebrities::photo))
|
||||
// administration
|
||||
.route("/v1/admin/users", get(admin::list_users))
|
||||
.route("/v1/admin/users/{id}", patch(admin::update_user))
|
||||
@@ -150,6 +154,18 @@ pub fn router(state: Arc<AppState>) -> Router {
|
||||
.route("/v1/admin/models/catalog", get(models::catalog))
|
||||
.route("/v1/admin/models/{kind}", axum::routing::put(models::save))
|
||||
.route("/v1/admin/analyses/{id}/regenerate", post(analyses::regenerate))
|
||||
.route("/v1/admin/celebrities", get(celebrities::list).post(celebrities::create))
|
||||
.route(
|
||||
"/v1/admin/celebrities/{id}",
|
||||
get(celebrities::get_one).patch(celebrities::update).delete(celebrities::remove),
|
||||
)
|
||||
.route("/v1/admin/celebrities/{id}/analysis", post(celebrities::request_analysis))
|
||||
.route(
|
||||
"/v1/admin/celebrities/{id}/photo",
|
||||
axum::routing::put(celebrities::upload_photo)
|
||||
.delete(celebrities::remove_photo)
|
||||
.layer(DefaultBodyLimit::max(crate::photo::MAX_UPLOAD + 1024)),
|
||||
)
|
||||
.route("/v1/admin/questions/{id}/regenerate", post(questions::regenerate))
|
||||
.layer(cors(&state.config.cors_allowed_origins))
|
||||
// The request log: masked paths, health checks only when they fail.
|
||||
|
||||
@@ -27,7 +27,8 @@ use crate::error::{ApiError, ApiResult};
|
||||
use crate::views::{rfc3339, rfc3339_opt};
|
||||
|
||||
/// The kinds whose prompt the admin page edits.
|
||||
const EDITABLE: [Kind; 5] = [Kind::Summary, Kind::Natal, Kind::Synastry, Kind::Forecast, Kind::Question];
|
||||
const EDITABLE: [Kind; 6] =
|
||||
[Kind::Summary, Kind::Natal, Kind::Synastry, Kind::Forecast, Kind::Question, Kind::Celebrity];
|
||||
const MAX_CHARS: usize = 50_000;
|
||||
const HISTORY: i64 = 20;
|
||||
/// Test runs of one admin waiting or being written at the same time.
|
||||
@@ -158,7 +159,8 @@ pub async fn save(
|
||||
pub struct StartPreview {
|
||||
/// The draft to try (it need not be saved).
|
||||
system: String,
|
||||
/// One of the admin's own charts (own or a person), for a summary or natal analysis.
|
||||
/// One of the admin's own charts (own or a person), for a summary or natal
|
||||
/// analysis; a famous person's chart (anyone's) for their analysis.
|
||||
chart_id: Option<Uuid>,
|
||||
/// One of the admin's own comparisons, for a synastry analysis.
|
||||
synastry_id: Option<Uuid>,
|
||||
@@ -216,7 +218,10 @@ pub async fn start_preview(
|
||||
let (chart_id, synastry_id, forecast_id) = (req.chart_id, req.synastry_id, req.forecast_id);
|
||||
let (query, id, what) = match (kind, chart_id, synastry_id, forecast_id) {
|
||||
(Kind::Summary | Kind::Natal, Some(id), None, None) => {
|
||||
("SELECT id FROM charts WHERE id = $1 AND owner_id = $2", id, "chart")
|
||||
("SELECT id FROM charts WHERE id = $1 AND owner_id = $2 AND kind <> 'celebrity'", id, "chart")
|
||||
}
|
||||
(Kind::Celebrity, Some(id), None, None) => {
|
||||
("SELECT chart_id FROM celebrities WHERE chart_id = $1 AND $2::uuid IS NOT NULL", id, "celebrity")
|
||||
}
|
||||
(Kind::Synastry, None, Some(id), None) => {
|
||||
("SELECT id FROM synastries WHERE id = $1 AND owner_id = $2", id, "synastry")
|
||||
|
||||
@@ -0,0 +1,276 @@
|
||||
//! Object storage for uploaded photos: any S3-compatible service, addressed
|
||||
//! path-style (`{endpoint}/{bucket}/{key}`). In production DigitalOcean
|
||||
//! Spaces, in development a RustFS container.
|
||||
//!
|
||||
//! The bucket stays private: the backend reads the objects itself and serves
|
||||
//! them under `/v1/public/photos/...`, from where the frontend's image
|
||||
//! optimizer makes the sized versions (and Cloudflare caches those).
|
||||
//!
|
||||
//! Requests are signed with AWS Signature Version 4.
|
||||
|
||||
use std::time::Duration;
|
||||
|
||||
use hmac::{Hmac, Mac};
|
||||
use sha2::{Digest, Sha256};
|
||||
use time::OffsetDateTime;
|
||||
|
||||
/// `S3_ENDPOINT` (e.g. `https://fra1.digitaloceanspaces.com`), `S3_BUCKET`,
|
||||
/// `S3_REGION` (default `us-east-1`; Spaces accepts it too),
|
||||
/// `S3_ACCESS_KEY_ID` and `S3_SECRET_ACCESS_KEY` (in `.env.secrets`).
|
||||
#[derive(Clone)]
|
||||
pub struct StorageConfig {
|
||||
pub endpoint: String,
|
||||
pub bucket: String,
|
||||
pub region: String,
|
||||
pub access_key: String,
|
||||
pub secret_key: String,
|
||||
}
|
||||
|
||||
// The secret stays out of logs.
|
||||
impl std::fmt::Debug for StorageConfig {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.debug_struct("StorageConfig")
|
||||
.field("endpoint", &self.endpoint)
|
||||
.field("bucket", &self.bucket)
|
||||
.field("region", &self.region)
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, thiserror::Error)]
|
||||
pub enum StorageError {
|
||||
#[error("object storage request failed: {0}")]
|
||||
Http(#[from] reqwest::Error),
|
||||
#[error("object storage answered {status}: {body}")]
|
||||
Status { status: u16, body: String },
|
||||
}
|
||||
|
||||
pub struct Storage {
|
||||
config: StorageConfig,
|
||||
http: reqwest::Client,
|
||||
}
|
||||
|
||||
/// An object read back: its bytes and content type.
|
||||
pub struct Object {
|
||||
pub bytes: axum::body::Bytes,
|
||||
pub content_type: Option<String>,
|
||||
}
|
||||
|
||||
impl Storage {
|
||||
pub fn new(config: StorageConfig) -> Self {
|
||||
let http = reqwest::Client::builder().timeout(Duration::from_secs(30)).build().expect("static configuration");
|
||||
Self { config, http }
|
||||
}
|
||||
|
||||
fn url(&self, key: &str) -> String {
|
||||
let path = if key.is_empty() { String::new() } else { format!("/{}", encode_path(key)) };
|
||||
format!("{}/{}{path}", self.config.endpoint, encode_segment(&self.config.bucket))
|
||||
}
|
||||
|
||||
async fn send(
|
||||
&self,
|
||||
method: reqwest::Method,
|
||||
key: &str,
|
||||
body: Vec<u8>,
|
||||
content_type: Option<&str>,
|
||||
) -> Result<reqwest::Response, StorageError> {
|
||||
let url = self.url(key);
|
||||
let parsed = reqwest::Url::parse(&url).map_err(|e| StorageError::Status { status: 0, body: e.to_string() })?;
|
||||
let host = match parsed.port() {
|
||||
Some(port) => format!("{}:{port}", parsed.host_str().unwrap_or_default()),
|
||||
None => parsed.host_str().unwrap_or_default().to_string(),
|
||||
};
|
||||
let payload_hash = hex(&Sha256::digest(&body));
|
||||
let now = OffsetDateTime::now_utc();
|
||||
let auth = authorization(&self.config, method.as_str(), parsed.path(), &host, &payload_hash, now);
|
||||
let mut request = self
|
||||
.http
|
||||
.request(method, url)
|
||||
.header("x-amz-date", amz_date(now))
|
||||
.header("x-amz-content-sha256", &payload_hash)
|
||||
.header("authorization", auth);
|
||||
if let Some(ct) = content_type {
|
||||
request = request.header("content-type", ct);
|
||||
}
|
||||
let response = request.body(body).send().await?;
|
||||
Ok(response)
|
||||
}
|
||||
|
||||
async fn checked(response: reqwest::Response) -> Result<reqwest::Response, StorageError> {
|
||||
if response.status().is_success() {
|
||||
return Ok(response);
|
||||
}
|
||||
let status = response.status().as_u16();
|
||||
let body = response.text().await.unwrap_or_default().chars().take(500).collect();
|
||||
Err(StorageError::Status { status, body })
|
||||
}
|
||||
|
||||
pub async fn put(&self, key: &str, body: Vec<u8>, content_type: &str) -> Result<(), StorageError> {
|
||||
Self::checked(self.send(reqwest::Method::PUT, key, body, Some(content_type)).await?).await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The object, or `None` if there is no such key.
|
||||
pub async fn get(&self, key: &str) -> Result<Option<Object>, StorageError> {
|
||||
let response = self.send(reqwest::Method::GET, key, Vec::new(), None).await?;
|
||||
if response.status() == reqwest::StatusCode::NOT_FOUND {
|
||||
return Ok(None);
|
||||
}
|
||||
let response = Self::checked(response).await?;
|
||||
let content_type = response.headers().get("content-type").and_then(|v| v.to_str().ok()).map(str::to_owned);
|
||||
Ok(Some(Object { bytes: response.bytes().await?, content_type }))
|
||||
}
|
||||
|
||||
/// Deletes the object; a missing one is not an error.
|
||||
pub async fn delete(&self, key: &str) -> Result<(), StorageError> {
|
||||
let response = self.send(reqwest::Method::DELETE, key, Vec::new(), None).await?;
|
||||
if response.status() == reqwest::StatusCode::NOT_FOUND {
|
||||
return Ok(());
|
||||
}
|
||||
Self::checked(response).await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Creates the bucket if it does not exist yet (development: a fresh
|
||||
/// RustFS container has none; in production it is made in the console).
|
||||
pub async fn ensure_bucket(&self) -> Result<(), StorageError> {
|
||||
let head = self.send(reqwest::Method::HEAD, "", Vec::new(), None).await?;
|
||||
if head.status().is_success() {
|
||||
return Ok(());
|
||||
}
|
||||
Self::checked(self.send(reqwest::Method::PUT, "", Vec::new(), None).await?).await?;
|
||||
tracing::info!(bucket = %self.config.bucket, "object storage bucket created");
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
type HmacSha256 = Hmac<Sha256>;
|
||||
|
||||
fn hmac(key: &[u8], data: &str) -> Vec<u8> {
|
||||
let mut mac = HmacSha256::new_from_slice(key).expect("HMAC takes any key length");
|
||||
mac.update(data.as_bytes());
|
||||
mac.finalize().into_bytes().to_vec()
|
||||
}
|
||||
|
||||
fn hex(bytes: &[u8]) -> String {
|
||||
bytes.iter().map(|b| format!("{b:02x}")).collect()
|
||||
}
|
||||
|
||||
fn amz_date(t: OffsetDateTime) -> String {
|
||||
format!(
|
||||
"{:04}{:02}{:02}T{:02}{:02}{:02}Z",
|
||||
t.year(),
|
||||
u8::from(t.month()),
|
||||
t.day(),
|
||||
t.hour(),
|
||||
t.minute(),
|
||||
t.second()
|
||||
)
|
||||
}
|
||||
|
||||
/// URI-encodes one path segment as SigV4 wants it (unreserved characters stay).
|
||||
fn encode_segment(s: &str) -> String {
|
||||
s.bytes()
|
||||
.map(|b| match b {
|
||||
b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => (b as char).to_string(),
|
||||
_ => format!("%{b:02X}"),
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn encode_path(key: &str) -> String {
|
||||
key.split('/').map(encode_segment).collect::<Vec<_>>().join("/")
|
||||
}
|
||||
|
||||
fn signing_key(secret: &str, date: &str, region: &str, service: &str) -> Vec<u8> {
|
||||
[date, region, service, "aws4_request"]
|
||||
.iter()
|
||||
.fold(format!("AWS4{secret}").into_bytes(), |key, part| hmac(&key, part))
|
||||
}
|
||||
|
||||
/// The `Authorization` header of a request (no query string; the path is
|
||||
/// already encoded, as in the URL).
|
||||
fn authorization(
|
||||
config: &StorageConfig,
|
||||
method: &str,
|
||||
path: &str,
|
||||
host: &str,
|
||||
payload_hash: &str,
|
||||
now: OffsetDateTime,
|
||||
) -> String {
|
||||
let date_time = amz_date(now);
|
||||
let date = &date_time[..8];
|
||||
let signed_headers = "host;x-amz-content-sha256;x-amz-date";
|
||||
let canonical = format!(
|
||||
"{method}\n{path}\n\nhost:{host}\nx-amz-content-sha256:{payload_hash}\nx-amz-date:{date_time}\n\n\
|
||||
{signed_headers}\n{payload_hash}"
|
||||
);
|
||||
let scope = format!("{date}/{}/s3/aws4_request", config.region);
|
||||
let to_sign = format!("AWS4-HMAC-SHA256\n{date_time}\n{scope}\n{}", hex(&Sha256::digest(canonical.as_bytes())));
|
||||
let signature = hex(&hmac(&signing_key(&config.secret_key, date, &config.region, "s3"), &to_sign));
|
||||
format!(
|
||||
"AWS4-HMAC-SHA256 Credential={}/{scope}, SignedHeaders={signed_headers}, Signature={signature}",
|
||||
config.access_key
|
||||
)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// The signing key example of the AWS documentation ("Examples of how to
|
||||
/// derive a signing key for Signature Version 4").
|
||||
#[test]
|
||||
fn derives_the_signing_key_like_aws() {
|
||||
let key = signing_key("wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY", "20150830", "us-east-1", "iam");
|
||||
assert_eq!(hex(&key), "c4afb1cc5771d871763a393e44b703571b55cc28424d1a5e86da6ed3c154a4b9");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn builds_the_authorization_header() {
|
||||
let config = StorageConfig {
|
||||
endpoint: "http://rustfs:9000".into(),
|
||||
bucket: "photos".into(),
|
||||
region: "us-east-1".into(),
|
||||
access_key: "AKIAIOSFODNN7EXAMPLE".into(),
|
||||
secret_key: "secret".into(),
|
||||
};
|
||||
let now = OffsetDateTime::from_unix_timestamp(1_369_353_600).unwrap();
|
||||
assert_eq!(amz_date(now), "20130524T000000Z");
|
||||
let empty = hex(&Sha256::digest(b""));
|
||||
assert_eq!(empty, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
|
||||
let auth = authorization(&config, "GET", "/photos/a.jpg", "rustfs:9000", &empty, now);
|
||||
assert!(auth.starts_with(
|
||||
"AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE/20130524/us-east-1/s3/aws4_request, \
|
||||
SignedHeaders=host;x-amz-content-sha256;x-amz-date, Signature="
|
||||
));
|
||||
let storage = Storage::new(config);
|
||||
assert_eq!(storage.url("celebrities/a b/ő.jpg"), "http://rustfs:9000/photos/celebrities/a%20b/%C5%91.jpg");
|
||||
assert_eq!(storage.url(""), "http://rustfs:9000/photos");
|
||||
}
|
||||
|
||||
/// Against a real S3 service (e.g. the RustFS container of development):
|
||||
/// `S3_TEST_ENDPOINT=http://127.0.0.1:9000 S3_TEST_KEY=… S3_TEST_SECRET=…
|
||||
/// cargo test -p backend live_round_trip -- --ignored`
|
||||
#[tokio::test]
|
||||
#[ignore]
|
||||
async fn live_round_trip() {
|
||||
let env = |name: &str| std::env::var(name).unwrap_or_else(|_| panic!("{name} is not set"));
|
||||
let storage = Storage::new(StorageConfig {
|
||||
endpoint: env("S3_TEST_ENDPOINT"),
|
||||
bucket: "storage-test".into(),
|
||||
region: "us-east-1".into(),
|
||||
access_key: env("S3_TEST_KEY"),
|
||||
secret_key: env("S3_TEST_SECRET"),
|
||||
});
|
||||
storage.ensure_bucket().await.unwrap();
|
||||
storage.ensure_bucket().await.unwrap();
|
||||
let key = "dir/próba kép.jpg";
|
||||
storage.put(key, b"hello".to_vec(), "image/jpeg").await.unwrap();
|
||||
let object = storage.get(key).await.unwrap().unwrap();
|
||||
assert_eq!((&object.bytes[..], object.content_type.as_deref()), (&b"hello"[..], Some("image/jpeg")));
|
||||
storage.delete(key).await.unwrap();
|
||||
assert!(storage.get(key).await.unwrap().is_none());
|
||||
storage.delete(key).await.unwrap();
|
||||
}
|
||||
}
|
||||
@@ -168,8 +168,44 @@ async fn fake_billingo_pdf(
|
||||
([("content-type", "application/pdf")], "%PDF-1.4 fake").into_response()
|
||||
}
|
||||
|
||||
async fn fake_services() -> String {
|
||||
/// A tiny S3: objects of the `photos` bucket in memory; signed requests only.
|
||||
type FakeS3 = Arc<std::sync::Mutex<std::collections::HashMap<String, (String, Vec<u8>)>>>;
|
||||
|
||||
async fn fake_s3(
|
||||
axum::extract::State(store): axum::extract::State<FakeS3>,
|
||||
method: axum::http::Method,
|
||||
headers: HeaderMap,
|
||||
axum::extract::Path(key): axum::extract::Path<String>,
|
||||
body: axum::body::Bytes,
|
||||
) -> axum::response::Response {
|
||||
use axum::response::IntoResponse;
|
||||
let auth = headers.get("authorization").and_then(|v| v.to_str().ok()).unwrap_or_default();
|
||||
if !auth.starts_with("AWS4-HMAC-SHA256 Credential=test-key/") || headers.get("x-amz-content-sha256").is_none() {
|
||||
return StatusCode::FORBIDDEN.into_response();
|
||||
}
|
||||
let mut store = store.lock().unwrap();
|
||||
match method.as_str() {
|
||||
"PUT" => {
|
||||
let ct = headers.get("content-type").and_then(|v| v.to_str().ok()).unwrap_or_default().to_string();
|
||||
store.insert(key, (ct, body.to_vec()));
|
||||
StatusCode::OK.into_response()
|
||||
}
|
||||
"GET" => match store.get(&key) {
|
||||
Some((ct, bytes)) => ([("content-type", ct.clone())], bytes.clone()).into_response(),
|
||||
None => StatusCode::NOT_FOUND.into_response(),
|
||||
},
|
||||
"DELETE" => {
|
||||
store.remove(&key);
|
||||
StatusCode::NO_CONTENT.into_response()
|
||||
}
|
||||
_ => StatusCode::METHOD_NOT_ALLOWED.into_response(),
|
||||
}
|
||||
}
|
||||
|
||||
async fn fake_services_with(s3: FakeS3) -> String {
|
||||
let objects = Router::new().route("/s3/photos/{*key}", get(fake_s3).put(fake_s3).delete(fake_s3)).with_state(s3);
|
||||
let app = Router::new()
|
||||
.merge(objects)
|
||||
.route("/billingo/documents/{id}/download", get(fake_billingo_pdf))
|
||||
.route("/openrouter/models", get(fake_openrouter_models))
|
||||
.route("/v1/checkout/sessions", post(fake_stripe_create))
|
||||
@@ -221,6 +257,8 @@ struct TestApp {
|
||||
router: Router,
|
||||
pool: PgPool,
|
||||
state: Arc<AppState>,
|
||||
/// The objects in the fake object storage.
|
||||
s3: FakeS3,
|
||||
}
|
||||
|
||||
struct Response {
|
||||
@@ -235,11 +273,29 @@ impl TestApp {
|
||||
}
|
||||
|
||||
async fn with_config(pool: PgPool, change: impl FnOnce(&mut Config)) -> Self {
|
||||
let fake = fake_services().await;
|
||||
let s3 = FakeS3::default();
|
||||
let fake = fake_services_with(s3.clone()).await;
|
||||
let mut config = Config::for_tests(String::new(), fake.clone(), format!("{fake}/jwks"));
|
||||
change(&mut config);
|
||||
let state = Arc::new(AppState::new(pool.clone(), config));
|
||||
Self { router: routes::router(state.clone()), pool, state }
|
||||
Self { router: routes::router(state.clone()), pool, state, s3 }
|
||||
}
|
||||
|
||||
/// A request with a raw body (an uploaded file); the response body as bytes.
|
||||
async fn call_raw(
|
||||
&self,
|
||||
method: &str,
|
||||
uri: &str,
|
||||
token: Option<&str>,
|
||||
body: Vec<u8>,
|
||||
) -> (StatusCode, HeaderMap, Vec<u8>) {
|
||||
let mut req = Request::builder().method(method).uri(uri).header("content-type", "application/octet-stream");
|
||||
if let Some(t) = token {
|
||||
req = req.header("authorization", format!("Bearer {t}"));
|
||||
}
|
||||
let resp = self.router.clone().oneshot(req.body(Body::from(body)).unwrap()).await.unwrap();
|
||||
let (status, headers) = (resp.status(), resp.headers().clone());
|
||||
(status, headers, resp.into_body().collect().await.unwrap().to_bytes().to_vec())
|
||||
}
|
||||
|
||||
async fn call(&self, method: &str, uri: &str, token: Option<&str>, body: Option<Value>) -> Response {
|
||||
@@ -941,7 +997,7 @@ async fn export_and_delete_account(pool: PgPool) {
|
||||
/// config and catalog, shared links, invitation pages, the waitlist and
|
||||
/// unsubscribing. Every other route (charts, calculations, analyses) needs a
|
||||
/// logged-in user, so other apps cannot use them.
|
||||
const PUBLIC_ROUTES: [&str; 19] = [
|
||||
const PUBLIC_ROUTES: [&str; 22] = [
|
||||
"/healthz",
|
||||
// Stripe calls it; the signature proves it.
|
||||
"/v1/payments/stripe/webhook",
|
||||
@@ -963,6 +1019,10 @@ const PUBLIC_ROUTES: [&str; 19] = [
|
||||
"/v1/public/chart",
|
||||
"/v1/public/geo/countries",
|
||||
"/v1/public/geo/places",
|
||||
// Famous people's pages (drafts only for admins) and their photos.
|
||||
"/v1/public/celebrities",
|
||||
"/v1/public/celebrities/{slug}",
|
||||
"/v1/public/photos/{*key}",
|
||||
];
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
@@ -1075,7 +1135,10 @@ async fn everything_else_needs_login(pool: PgPool) {
|
||||
let source = include_str!("routes/mod.rs");
|
||||
let id = uuid::Uuid::now_v7().to_string();
|
||||
let mut checked = 0;
|
||||
for line in source.lines().map(str::trim).filter(|l| l.starts_with(".route(\"")) {
|
||||
// One route per item, also when rustfmt broke it into several lines.
|
||||
let flat = source.split_whitespace().collect::<Vec<_>>().join(" ").replace(".route( \"", ".route(\"");
|
||||
for line in flat.split(".route(\"").skip(1).map(|r| format!(".route(\"{}", r.split(".layer(cors").next().unwrap()))
|
||||
{
|
||||
let path = line.split('"').nth(1).unwrap();
|
||||
if PUBLIC_ROUTES.contains(&path) {
|
||||
continue;
|
||||
@@ -1334,8 +1397,8 @@ async fn admins_edit_analysis_prompts(pool: PgPool) {
|
||||
let prompts = r.body["prompts"].as_array().unwrap();
|
||||
let keys: Vec<String> =
|
||||
prompts.iter().map(|p| format!("{}/{}", p["kind"], p["language"]).replace('"', "")).collect();
|
||||
let expected =
|
||||
["summary", "natal", "synastry", "forecast", "question"].map(|k| [format!("{k}/hu"), format!("{k}/en")]);
|
||||
let expected = ["summary", "natal", "synastry", "forecast", "question", "celebrity"]
|
||||
.map(|k| [format!("{k}/hu"), format!("{k}/en")]);
|
||||
assert_eq!(keys, expected.concat());
|
||||
let natal = &prompts[2];
|
||||
assert_eq!((&natal["custom"], &natal["system"]), (&json!(false), &natal["default"]));
|
||||
@@ -2899,3 +2962,140 @@ async fn a_paid_forecast_fixes_the_person(pool: PgPool) {
|
||||
let r = app.call("PATCH", &format!("/v1/charts/{bela_id}"), Some(&anna), Some(corrected)).await;
|
||||
assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::CONFLICT, Some("person_analysed")));
|
||||
}
|
||||
|
||||
fn test_png(width: u32, height: u32) -> Vec<u8> {
|
||||
let img = image::RgbImage::from_pixel(width, height, image::Rgb([180, 140, 90]));
|
||||
let mut out = Vec::new();
|
||||
img.write_to(&mut std::io::Cursor::new(&mut out), image::ImageFormat::Png).unwrap();
|
||||
out
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn admins_publish_famous_people_with_a_photo(pool: PgPool) {
|
||||
let app = TestApp::new(pool.clone()).await;
|
||||
let admin = app.register("admin@example.com", "Admin").await;
|
||||
let anna = app.register("anna@example.com", "Anna").await;
|
||||
let birth = json!({"date": "1926-06-01", "time": "09:30", "country": "HU", "place": "Szeged"});
|
||||
let new = json!({"name": " Teszt Elek ", "subtitle": "színész", "birth": birth});
|
||||
assert_eq!(app.post("/v1/admin/celebrities", Some(&anna), new.clone()).await.status, StatusCode::FORBIDDEN);
|
||||
|
||||
// added: the chart is calculated and the analysis queued, free of charge
|
||||
let r = app.post("/v1/admin/celebrities", Some(&admin), new.clone()).await;
|
||||
assert_eq!(r.status, StatusCode::CREATED, "{}", r.body);
|
||||
let c = r.body;
|
||||
let id = c["id"].as_str().unwrap().to_string();
|
||||
assert_eq!((c["name"].as_str(), c["slug"].as_str()), (Some("Teszt Elek"), Some("teszt-elek")));
|
||||
assert_eq!((&c["published"], &c["photo"]), (&json!(false), &Value::Null));
|
||||
assert_eq!((c["birth"]["date"].as_str(), c["birth"]["time"].as_str()), (Some("1926-06-01"), Some("09:30")));
|
||||
let analysis = &c["analysis"];
|
||||
assert_eq!((analysis["kind"].as_str(), analysis["status"].as_str()), (Some("celebrity"), Some("pending")));
|
||||
assert_eq!((analysis["credits_charged"].as_i64(), analysis["language"].as_str()), (Some(0), Some("hu")));
|
||||
let analysis_id = analysis["id"].as_str().unwrap().to_string();
|
||||
// the same name again gets its own address
|
||||
let r = app.post("/v1/admin/celebrities", Some(&admin), new.clone()).await;
|
||||
assert_eq!(r.body["slug"].as_str(), Some("teszt-elek-2"));
|
||||
let second = r.body["id"].as_str().unwrap().to_string();
|
||||
|
||||
// not among the admin's own charts, and the chart routes do not reach it
|
||||
let charts = app.get("/v1/charts", Some(&admin)).await.body;
|
||||
assert_eq!(charts["charts"].as_array().unwrap().len(), 0, "{charts}");
|
||||
let (chart_id,): (uuid::Uuid,) = sqlx::query_as("SELECT chart_id FROM celebrities WHERE id = $1::uuid")
|
||||
.bind(&id)
|
||||
.fetch_one(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(app.get(&format!("/v1/charts/{chart_id}"), Some(&admin)).await.status, StatusCode::NOT_FOUND);
|
||||
let r = app.call("DELETE", &format!("/v1/charts/{chart_id}"), Some(&admin), None).await;
|
||||
assert_eq!(r.status, StatusCode::NOT_FOUND);
|
||||
|
||||
// a draft: only admins see the page
|
||||
assert_eq!(app.get("/v1/public/celebrities/teszt-elek", None).await.status, StatusCode::NOT_FOUND);
|
||||
assert_eq!(app.get("/v1/public/celebrities/teszt-elek", Some(&anna)).await.status, StatusCode::NOT_FOUND);
|
||||
let r = app.get("/v1/public/celebrities/teszt-elek", Some(&admin)).await;
|
||||
assert_eq!((r.status, &r.body["analysis"]), (StatusCode::OK, &Value::Null));
|
||||
assert_eq!(app.get("/v1/public/celebrities", None).await.body["celebrities"], json!([]));
|
||||
|
||||
// the photo: stored once as JPEG under a new key, the old one deleted
|
||||
let uri = format!("/v1/admin/celebrities/{id}/photo");
|
||||
let (status, _, body) = app.call_raw("PUT", &uri, Some(&admin), b"not an image".to_vec()).await;
|
||||
assert_eq!(status, StatusCode::BAD_REQUEST, "{}", String::from_utf8_lossy(&body));
|
||||
let (status, _, body) = app.call_raw("PUT", &uri, Some(&admin), test_png(3000, 4000)).await;
|
||||
assert_eq!(status, StatusCode::OK, "{}", String::from_utf8_lossy(&body));
|
||||
let photo = serde_json::from_slice::<Value>(&body).unwrap()["photo"].clone();
|
||||
assert_eq!((photo["width"].as_i64(), photo["height"].as_i64()), (Some(1500), Some(2000)));
|
||||
let first_key = photo["key"].as_str().unwrap().to_string();
|
||||
assert!(first_key.starts_with(&format!("celebrities/{id}/")) && first_key.ends_with(".jpg"));
|
||||
let (status, _, body) = app.call_raw("PUT", &uri, Some(&admin), test_png(800, 800)).await;
|
||||
assert_eq!(status, StatusCode::OK);
|
||||
let key = serde_json::from_slice::<Value>(&body).unwrap()["photo"]["key"].as_str().unwrap().to_string();
|
||||
assert_ne!(key, first_key);
|
||||
{
|
||||
let s3 = app.s3.lock().unwrap();
|
||||
assert!(!s3.contains_key(&first_key) && s3.contains_key(&key));
|
||||
assert_eq!(s3[&key].0, "image/jpeg");
|
||||
}
|
||||
// served while in use, cacheable for good; the replaced one is gone
|
||||
let (status, headers, bytes) = app.call_raw("GET", &format!("/v1/public/photos/{key}"), None, vec![]).await;
|
||||
assert_eq!(status, StatusCode::OK);
|
||||
assert_eq!(headers["cache-control"], "public, max-age=31536000, immutable");
|
||||
assert_eq!(&bytes[..3], &[0xFF, 0xD8, 0xFF]);
|
||||
let (status, ..) = app.call_raw("GET", &format!("/v1/public/photos/{first_key}"), None, vec![]).await;
|
||||
assert_eq!(status, StatusCode::NOT_FOUND);
|
||||
|
||||
// edits: face point, address, publishing
|
||||
let item = format!("/v1/admin/celebrities/{id}");
|
||||
let patch = |body: Value| app.call("PATCH", &item, Some(&admin), Some(body));
|
||||
let r = patch(json!({"slug": "Rossz Cím"})).await;
|
||||
assert_eq!(r.status, StatusCode::BAD_REQUEST);
|
||||
let r = patch(json!({"slug": "teszt-elek-2"})).await;
|
||||
assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::CONFLICT, Some("slug_taken")));
|
||||
let r = patch(json!({"focus_x": 0.25, "focus_y": 7.0, "published": true, "subtitle": null})).await;
|
||||
assert_eq!(r.status, StatusCode::OK, "{}", r.body);
|
||||
assert_eq!((&r.body["photo"]["focus_x"], &r.body["photo"]["focus_y"]), (&json!(0.25), &json!(1.0)));
|
||||
assert_eq!((&r.body["published"], &r.body["subtitle"]), (&json!(true), &Value::Null));
|
||||
|
||||
// published: the list and the page, with the birth data, the chart and the finished analysis
|
||||
sqlx::query("UPDATE analyses SET status = 'done', content = '{\"title\": \"Portré\"}', completed_at = now() WHERE id = $1::uuid")
|
||||
.bind(&analysis_id)
|
||||
.execute(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
// someone else with the very same chart gets their own portrait (the text has the name in it)
|
||||
let twin = json!({"name": "Teszt Ikertestvér", "birth": birth});
|
||||
let r = app.post("/v1/admin/celebrities", Some(&admin), twin).await;
|
||||
assert_eq!(r.body["analysis"]["status"].as_str(), Some("pending"), "{}", r.body);
|
||||
let twin_id = r.body["id"].as_str().unwrap().to_string();
|
||||
let r = app.call("DELETE", &format!("/v1/admin/celebrities/{twin_id}"), Some(&admin), None).await;
|
||||
assert_eq!(r.status, StatusCode::NO_CONTENT);
|
||||
|
||||
let list = app.get("/v1/public/celebrities", None).await.body;
|
||||
assert_eq!(list["celebrities"].as_array().unwrap().len(), 1, "{list}");
|
||||
assert_eq!(list["celebrities"][0]["highlights"]["sun"], "cancer");
|
||||
let page = app.get("/v1/public/celebrities/teszt-elek", None).await;
|
||||
assert_eq!(page.status, StatusCode::OK);
|
||||
assert_eq!(page.body["analysis"]["content"]["title"], "Portré");
|
||||
assert_eq!(page.body["chart"]["birth"]["place"], "Szeged");
|
||||
assert_eq!(page.body["photo"]["key"].as_str(), Some(key.as_str()));
|
||||
|
||||
// corrected birth data: a new chart and a new analysis
|
||||
let r = patch(json!({"birth": {"date": "1926-06-02", "time": "09:30", "country": "HU", "place": "Szeged"}})).await;
|
||||
assert_eq!(r.status, StatusCode::OK, "{}", r.body);
|
||||
assert_eq!(r.body["birth"]["date"].as_str(), Some("1926-06-02"));
|
||||
assert_ne!(r.body["analysis"]["id"].as_str(), Some(analysis_id.as_str()));
|
||||
assert_eq!(r.body["analysis"]["status"].as_str(), Some("pending"));
|
||||
|
||||
// the prompt can be tried on a famous person's chart
|
||||
let r = app
|
||||
.post("/v1/admin/prompts/celebrity/hu/preview", Some(&admin), json!({"system": "Próba.", "chart_id": chart_id}))
|
||||
.await;
|
||||
assert_eq!(r.status, StatusCode::ACCEPTED, "{}", r.body);
|
||||
|
||||
// deleted with the photo; the other one stays
|
||||
let r = app.call("DELETE", &format!("/v1/admin/celebrities/{id}"), Some(&admin), None).await;
|
||||
assert_eq!(r.status, StatusCode::NO_CONTENT);
|
||||
assert!(app.s3.lock().unwrap().is_empty());
|
||||
assert_eq!(app.get("/v1/public/celebrities/teszt-elek", None).await.status, StatusCode::NOT_FOUND);
|
||||
let left = app.get("/v1/admin/celebrities", Some(&admin)).await.body;
|
||||
assert_eq!(left["celebrities"].as_array().unwrap().len(), 1);
|
||||
assert_eq!(left["celebrities"][0]["id"].as_str(), Some(second.as_str()));
|
||||
}
|
||||
|
||||
@@ -54,6 +54,7 @@ pub fn public_chart(result: &Value, show_birth_data: bool) -> Value {
|
||||
"place": result["location"]["place"]["name"],
|
||||
"region": result["location"]["place"]["region"],
|
||||
"country": result["location"]["country"]["name"],
|
||||
"country_code": result["location"]["country"]["iso2"],
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user