Files
sorsfonalak/services/backend/src/routes/invitations.rs
T
fecoandClaude Opus 5.5 7272d0f1f3 Invitation-only sign-up, invitation e-mails and waitlist
- SIGNUP_MODE=invite (default): a new account needs an open invitation for
  its address, or the invitation link (then any Google account will do)
- admin page "Meghívók": invite many addresses at once, personal message,
  resend (max 3, 24 h apart), revoke, copy link, mail preview and test copy,
  waitlist
- invitation e-mail in HTML and plain text; Message-ID on the sender's
  domain, List-Unsubscribe with one-click POST, opt-out list (hashes only)
- e-mail texts moved to a shared crate (crates/email-templates)
- login page shows the invitation; waitlist for uninvited visitors;
  unsubscribe page; privacy policy updated
- docs/levelkuldes.md: Brevo, DNS (SPF, DKIM, DMARC) and the SMTP setup

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012vLHzh5qUhFtmJhzkcTbXL
2026-11-17 18:37:15 +00:00

548 lines
20 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Invitations to the closed site.
//!
//! While `SIGNUP_MODE=invite`, a new account needs an open invitation for its
//! e-mail address, or an invitation link (then any address will do, because
//! people often sign in with another Google account than the one their friend
//! knows). Only administrators invite; the worker sends the e-mails.
//!
//! People who asked for no more invitations are kept as the hash of their
//! address. People without an invitation can join the waitlist.
use axum::Json;
use axum::extract::{Path, Query, State};
use axum::http::StatusCode;
use axum_extra::extract::WithRejection;
use serde::Deserialize;
use serde_json::{Value, json};
use sqlx::PgConnection;
use time::OffsetDateTime;
use uuid::Uuid;
use super::auth::{normalize_email, queue_email_to, validate_locale};
use super::{Body, IdPath, St};
use crate::AppState;
use crate::auth::AdminUser;
use crate::config::SignupMode;
use crate::error::{ApiError, ApiResult};
use crate::views::{rfc3339, rfc3339_opt};
pub const INVITATION_TTL: time::Duration = time::Duration::days(30);
/// A resend is possible this often, and at most this many sendings in all.
const RESEND_GAP: time::Duration = time::Duration::hours(24);
const MAX_SENDINGS: i32 = 3;
const MAX_MESSAGE_CHARS: usize = 300;
const MAX_BATCH: usize = 50;
// --- the gate -------------------------------------------------------------------------------
/// Whether a new account may be created for `email` (with the invitation link
/// `token`, if the visitor came through one).
pub async fn admit(
state: &AppState,
conn: &mut PgConnection,
email: &str,
token: Option<&str>,
) -> Result<(), ApiError> {
if state.config.signup_mode == SignupMode::Open || state.config.bootstrap_admin_emails.iter().any(|e| e == email) {
return Ok(());
}
let hash = token.map(|t| db::token_hash(t.trim()));
let invited: bool = sqlx::query_scalar(
"SELECT EXISTS (SELECT 1 FROM invitations i WHERE i.accepted_at IS NULL AND i.revoked_at IS NULL \
AND i.expires_at > now() \
AND (i.email = $1 OR i.id IN (SELECT invitation_id FROM invitation_tokens WHERE token_hash = $2))) \
-- a \"how compatible are we?\" link also lets the invitee in
OR EXISTS (SELECT 1 FROM synastry_invites WHERE token_hash = $2 AND accepted_at IS NULL AND expires_at > now())",
)
.bind(email)
.bind(hash)
.fetch_one(&mut *conn)
.await?;
if invited {
Ok(())
} else {
Err(ApiError::Refused {
code: "not_invited",
message: "A Sorsfonalak jelenleg meghívásos: ehhez az e-mail-címhez nem tartozik meghívó.".into(),
})
}
}
/// After a new account is created: its invitations count as accepted, and it leaves the waitlist.
pub async fn mark_accepted(
conn: &mut PgConnection,
user_id: Uuid,
email: &str,
token: Option<&str>,
) -> Result<(), ApiError> {
let hash = token.map(|t| db::token_hash(t.trim()));
sqlx::query(
"UPDATE invitations SET accepted_at = now(), accepted_by = $1 \
WHERE accepted_at IS NULL AND revoked_at IS NULL \
AND (email = $2 OR (expires_at > now() AND id IN (SELECT invitation_id FROM invitation_tokens WHERE token_hash = $3)))",
)
.bind(user_id)
.bind(email)
.bind(hash)
.execute(&mut *conn)
.await?;
sqlx::query("DELETE FROM waitlist WHERE email = $1").bind(email).execute(&mut *conn).await?;
Ok(())
}
// --- sending ---------------------------------------------------------------------------------
fn clean_message(message: Option<String>) -> Result<Option<String>, ApiError> {
let Some(message) = message.map(|m| m.replace("\r\n", "\n").trim().to_owned()).filter(|m| !m.is_empty()) else {
return Ok(None);
};
if message.chars().count() > MAX_MESSAGE_CHARS {
return Err(ApiError::BadRequest(format!("A személyes üzenet legfeljebb {MAX_MESSAGE_CHARS} karakter lehet.")));
}
// Links in a mail from our domain are what spammers would use this field for.
let lower = message.to_lowercase();
if lower.contains("://") || lower.contains("www.") {
return Err(ApiError::BadRequest("A személyes üzenetben nem lehet link.".into()));
}
Ok(Some(message))
}
fn links(state: &AppState, token: &str) -> (String, String, String) {
let base = &state.config.public_base_url;
(
format!("{base}/meghivo/{token}"),
format!("{base}/leiratkozas?token={token}"),
format!("{base}/api/v1/public/invitations/unsubscribe?token={token}"),
)
}
fn payload(
state: &AppState,
token: &str,
inviter: Option<&str>,
message: Option<&str>,
expires: OffsetDateTime,
) -> Value {
let (url, unsubscribe_url, unsubscribe_post_url) = links(state, token);
json!({
"url": url,
"unsubscribe_url": unsubscribe_url,
"unsubscribe_post_url": unsubscribe_post_url,
"inviter_name": inviter,
"message": message,
"expires_on": expires.date().to_string(),
})
}
/// Issues a new link token for an invitation and queues the e-mail; returns the link.
#[allow(clippy::too_many_arguments)]
async fn send(
state: &AppState,
conn: &mut PgConnection,
id: Uuid,
email: &str,
locale: &str,
inviter: Option<&str>,
message: Option<&str>,
expires: OffsetDateTime,
) -> Result<String, ApiError> {
let token = db::new_token();
sqlx::query("INSERT INTO invitation_tokens (token_hash, invitation_id) VALUES ($1, $2)")
.bind(db::token_hash(&token))
.bind(id)
.execute(&mut *conn)
.await?;
let payload = payload(state, &token, inviter, message, expires);
let url = payload["url"].as_str().unwrap_or_default().to_owned();
queue_email_to(conn, None, email, "invitation", locale, payload).await?;
Ok(url)
}
async fn opted_out(conn: &mut PgConnection, email: &str) -> Result<bool, ApiError> {
Ok(sqlx::query_scalar("SELECT EXISTS (SELECT 1 FROM email_optouts WHERE email_hash = $1)")
.bind(db::token_hash(email))
.fetch_one(conn)
.await?)
}
// --- admin ------------------------------------------------------------------------------------
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub struct CreateInvitations {
emails: Vec<String>,
message: Option<String>,
locale: Option<String>,
}
/// Invites a list of addresses. Each gets a result: `invited` (with the
/// link, to pass on by hand if needed), `already_user`, `already_invited`,
/// `opted_out` or `invalid`.
pub async fn create(
State(state): St,
AdminUser(admin): AdminUser,
WithRejection(Json(req), _): Body<CreateInvitations>,
) -> ApiResult<(StatusCode, Json<Value>)> {
if req.emails.is_empty() || req.emails.len() > MAX_BATCH {
return Err(ApiError::BadRequest(format!("1–{MAX_BATCH} e-mail-cím adható meg egyszerre.")));
}
let message = clean_message(req.message)?;
let locale = validate_locale(&state, req.locale.as_deref())?;
let inviter = admin.user.display_name.clone();
let mut results = Vec::new();
let mut seen = std::collections::HashSet::new();
let mut tx = state.db.begin().await?;
for raw in &req.emails {
let raw = raw.trim();
let Ok(email) = normalize_email(raw) else {
results.push(json!({ "email": raw, "status": "invalid" }));
continue;
};
if !seen.insert(email.clone()) {
continue;
}
let user: bool = sqlx::query_scalar("SELECT EXISTS (SELECT 1 FROM users WHERE email = $1)")
.bind(&email)
.fetch_one(&mut *tx)
.await?;
if user {
results.push(json!({ "email": email, "status": "already_user" }));
continue;
}
if opted_out(&mut tx, &email).await? {
results.push(json!({ "email": email, "status": "opted_out" }));
continue;
}
// An expired open invitation gives way to the new one.
sqlx::query(
"UPDATE invitations SET revoked_at = now() \
WHERE email = $1 AND accepted_at IS NULL AND revoked_at IS NULL AND expires_at <= now()",
)
.bind(&email)
.execute(&mut *tx)
.await?;
let id = Uuid::now_v7();
let expires = OffsetDateTime::now_utc() + INVITATION_TTL;
let inserted = sqlx::query(
"INSERT INTO invitations (id, email, message, locale, invited_by, expires_at) \
VALUES ($1, $2, $3, $4, $5, $6) ON CONFLICT DO NOTHING",
)
.bind(id)
.bind(&email)
.bind(&message)
.bind(&locale)
.bind(admin.id())
.bind(expires)
.execute(&mut *tx)
.await?
.rows_affected();
if inserted == 0 {
results.push(json!({ "email": email, "status": "already_invited" }));
continue;
}
let url = send(&state, &mut tx, id, &email, &locale, inviter.as_deref(), message.as_deref(), expires).await?;
results.push(json!({ "email": email, "status": "invited", "id": id, "url": url }));
}
tx.commit().await?;
Ok((StatusCode::CREATED, Json(json!({ "results": results }))))
}
#[derive(sqlx::FromRow)]
struct Row {
id: Uuid,
email: String,
message: Option<String>,
locale: String,
created_at: OffsetDateTime,
expires_at: OffsetDateTime,
sent_count: i32,
last_sent_at: OffsetDateTime,
accepted_at: Option<OffsetDateTime>,
revoked_at: Option<OffsetDateTime>,
invited_by_name: Option<String>,
accepted_by_name: Option<String>,
mail_created_at: Option<OffsetDateTime>,
mail_sent_at: Option<OffsetDateTime>,
mail_failed_at: Option<OffsetDateTime>,
mail_error: Option<String>,
}
fn status(accepted: Option<OffsetDateTime>, revoked: Option<OffsetDateTime>, expires: OffsetDateTime) -> &'static str {
if accepted.is_some() {
"accepted"
} else if revoked.is_some() {
"revoked"
} else if expires <= OffsetDateTime::now_utc() {
"expired"
} else {
"pending"
}
}
/// Every invitation (newest first) with the state of its last e-mail, and the waitlist.
pub async fn list(State(state): St, _admin: AdminUser) -> ApiResult<Json<Value>> {
let rows: Vec<Row> = sqlx::query_as(
"SELECT i.id, i.email, i.message, i.locale, i.created_at, i.expires_at, i.sent_count, i.last_sent_at, \
i.accepted_at, i.revoked_at, inv.display_name AS invited_by_name, \
coalesce(acc.display_name, acc.email) AS accepted_by_name, \
m.created_at AS mail_created_at, m.sent_at AS mail_sent_at, m.failed_at AS mail_failed_at, m.last_error AS mail_error \
FROM invitations i \
LEFT JOIN users inv ON inv.id = i.invited_by \
LEFT JOIN users acc ON acc.id = i.accepted_by \
LEFT JOIN LATERAL (SELECT created_at, sent_at, failed_at, last_error FROM email_outbox \
WHERE to_email = i.email AND template = 'invitation' \
ORDER BY created_at DESC LIMIT 1) m ON true \
ORDER BY i.created_at DESC LIMIT 500",
)
.fetch_all(&state.db)
.await?;
let now = OffsetDateTime::now_utc();
let invitations: Vec<Value> = rows
.into_iter()
.map(|r| {
let status = status(r.accepted_at, r.revoked_at, r.expires_at);
// Sent e-mails are removed from the outbox after a week.
let mail = match (r.mail_created_at, r.mail_sent_at, r.mail_failed_at) {
(None, _, _) => "archived",
(_, Some(_), _) => "sent",
(_, None, Some(_)) => "failed",
_ => "queued",
};
let can_resend = matches!(status, "pending" | "expired")
&& r.sent_count < MAX_SENDINGS
&& r.last_sent_at + RESEND_GAP <= now;
json!({
"id": r.id, "email": r.email, "message": r.message, "locale": r.locale, "status": status,
"created_at": rfc3339(r.created_at), "expires_at": rfc3339(r.expires_at),
"sent_count": r.sent_count, "last_sent_at": rfc3339(r.last_sent_at),
"accepted_at": rfc3339_opt(r.accepted_at), "accepted_by": r.accepted_by_name,
"invited_by": r.invited_by_name,
"mail": mail, "mail_error": r.mail_error, "can_resend": can_resend,
})
})
.collect();
let waitlist: Vec<(String, String, OffsetDateTime, Option<String>)> = sqlx::query_as(
"SELECT w.email, w.locale, w.created_at, \
(SELECT CASE WHEN accepted_at IS NOT NULL THEN 'accepted' WHEN expires_at > now() THEN 'pending' END \
FROM invitations WHERE email = w.email AND revoked_at IS NULL ORDER BY created_at DESC LIMIT 1) \
FROM waitlist w ORDER BY w.created_at",
)
.fetch_all(&state.db)
.await?;
let waitlist: Vec<Value> = waitlist
.into_iter()
.map(|(email, locale, created, invitation)| {
json!({ "email": email, "locale": locale, "created_at": rfc3339(created), "invitation": invitation })
})
.collect();
Ok(Json(
json!({ "invitations": invitations, "waitlist": waitlist, "signup_mode": state.config.signup_mode.as_str() }),
))
}
/// Sends the invitation again with a new link (the earlier links keep
/// working), and gives it another 30 days.
pub async fn resend(
State(state): St,
AdminUser(admin): AdminUser,
WithRejection(Path(id), _): IdPath,
) -> ApiResult<Json<Value>> {
let mut tx = state.db.begin().await?;
#[derive(sqlx::FromRow)]
struct Open {
email: String,
message: Option<String>,
locale: String,
sent_count: i32,
last_sent_at: OffsetDateTime,
closed: bool,
}
let Open { email, message, locale, sent_count, last_sent_at: last_sent, closed } = sqlx::query_as(
"SELECT email, message, locale, sent_count, last_sent_at, \
accepted_at IS NOT NULL OR revoked_at IS NOT NULL AS closed \
FROM invitations WHERE id = $1 FOR UPDATE",
)
.bind(id)
.fetch_optional(&mut *tx)
.await?
.ok_or(ApiError::NotFound("invitation"))?;
if closed {
return Err(ApiError::conflict("invitation_closed", "Ezt a meghívót már elfogadták vagy visszavonták."));
}
if sent_count >= MAX_SENDINGS {
return Err(ApiError::conflict(
"resend_limit",
format!("Egy meghívó legfeljebb {MAX_SENDINGS}-szor küldhető el (spamvédelem)."),
));
}
if last_sent + RESEND_GAP > OffsetDateTime::now_utc() {
return Err(ApiError::conflict("resend_too_soon", "Újraküldés legkorábban 24 órával az előző küldés után."));
}
if opted_out(&mut tx, &email).await? {
return Err(ApiError::conflict("opted_out", "Ez a cím leiratkozott a meghívókról."));
}
let expires = OffsetDateTime::now_utc() + INVITATION_TTL;
sqlx::query(
"UPDATE invitations SET sent_count = sent_count + 1, last_sent_at = now(), expires_at = $2 WHERE id = $1",
)
.bind(id)
.bind(expires)
.execute(&mut *tx)
.await?;
let inviter = admin.user.display_name.clone();
let url = send(&state, &mut tx, id, &email, &locale, inviter.as_deref(), message.as_deref(), expires).await?;
tx.commit().await?;
Ok(Json(json!({ "id": id, "url": url, "expires_at": rfc3339(expires) })))
}
pub async fn revoke(State(state): St, _admin: AdminUser, WithRejection(Path(id), _): IdPath) -> ApiResult<StatusCode> {
let done = sqlx::query(
"UPDATE invitations SET revoked_at = now() WHERE id = $1 AND accepted_at IS NULL AND revoked_at IS NULL",
)
.bind(id)
.execute(&state.db)
.await?
.rows_affected();
if done == 0 {
return Err(ApiError::NotFound("open invitation"));
}
Ok(StatusCode::NO_CONTENT)
}
pub async fn remove_from_waitlist(
State(state): St,
_admin: AdminUser,
WithRejection(Path(email), _): WithRejection<Path<String>, ApiError>,
) -> ApiResult<StatusCode> {
sqlx::query("DELETE FROM waitlist WHERE email = $1").bind(email.trim().to_lowercase()).execute(&state.db).await?;
Ok(StatusCode::NO_CONTENT)
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub struct PreviewRequest {
message: Option<String>,
locale: Option<String>,
/// Also send it to the admin's own address.
#[serde(default)]
send_to_me: bool,
}
/// The invitation e-mail with sample links (they lead nowhere), and
/// optionally a test copy to the admin.
pub async fn preview(
State(state): St,
AdminUser(admin): AdminUser,
WithRejection(Json(req), _): Body<PreviewRequest>,
) -> ApiResult<Json<Value>> {
let message = clean_message(req.message)?;
let locale = validate_locale(&state, req.locale.as_deref())?;
let payload = payload(
&state,
"minta",
admin.user.display_name.as_deref(),
message.as_deref(),
OffsetDateTime::now_utc() + INVITATION_TTL,
);
let mail = email_templates::render("invitation", &locale, &payload)
.map_err(|e| ApiError::Internal(format!("invitation template: {e}")))?;
if req.send_to_me {
let mut conn = state.db.acquire().await?;
queue_email_to(&mut conn, Some(admin.id()), &admin.user.email, "invitation", &locale, payload).await?;
}
Ok(Json(json!({
"subject": mail.subject, "text": mail.text, "html": mail.html,
"sent_to": req.send_to_me.then_some(&admin.user.email),
})))
}
// --- public -------------------------------------------------------------------------------------
/// Landing data of an invitation link.
pub async fn public_view(State(state): St, Path(token): Path<String>) -> ApiResult<Json<Value>> {
#[derive(sqlx::FromRow)]
struct Landing {
inviter: Option<String>,
message: Option<String>,
expires_at: OffsetDateTime,
accepted_at: Option<OffsetDateTime>,
revoked_at: Option<OffsetDateTime>,
}
let l: Landing = sqlx::query_as(
"SELECT u.display_name AS inviter, i.message, i.expires_at, i.accepted_at, i.revoked_at \
FROM invitation_tokens t JOIN invitations i ON i.id = t.invitation_id \
LEFT JOIN users u ON u.id = i.invited_by WHERE t.token_hash = $1",
)
.bind(db::token_hash(token.trim()))
.fetch_optional(&state.db)
.await?
.ok_or(ApiError::NotFound("invitation"))?;
Ok(Json(json!({
"inviter_name": l.inviter,
"message": l.message,
"status": status(l.accepted_at, l.revoked_at, l.expires_at),
"expires_at": rfc3339(l.expires_at),
})))
}
#[derive(Deserialize)]
pub struct TokenQuery {
token: String,
}
/// "No more invitations": from the page behind the footer link, or straight
/// from the mail client's unsubscribe button (RFC 8058 one-click POST).
pub async fn unsubscribe(
State(state): St,
WithRejection(Query(q), _): WithRejection<Query<TokenQuery>, ApiError>,
) -> ApiResult<Json<Value>> {
let mut tx = state.db.begin().await?;
let email: Option<String> = sqlx::query_scalar(
"SELECT i.email FROM invitation_tokens t JOIN invitations i ON i.id = t.invitation_id WHERE t.token_hash = $1",
)
.bind(db::token_hash(q.token.trim()))
.fetch_optional(&mut *tx)
.await?;
let email = email.ok_or(ApiError::NotFound("invitation"))?;
sqlx::query("INSERT INTO email_optouts (email_hash) VALUES ($1) ON CONFLICT DO NOTHING")
.bind(db::token_hash(&email))
.execute(&mut *tx)
.await?;
sqlx::query(
"UPDATE invitations SET revoked_at = now() WHERE email = $1 AND accepted_at IS NULL AND revoked_at IS NULL",
)
.bind(&email)
.execute(&mut *tx)
.await?;
tx.commit().await?;
Ok(Json(json!({ "unsubscribed": true })))
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub struct WaitlistRequest {
email: String,
locale: Option<String>,
}
/// Joins the waitlist. Always answers the same, so it does not reveal who has an account.
pub async fn join_waitlist(
State(state): St,
WithRejection(Json(req), _): Body<WaitlistRequest>,
) -> ApiResult<(StatusCode, Json<Value>)> {
let email = normalize_email(&req.email)?;
let locale = validate_locale(&state, req.locale.as_deref())?;
sqlx::query(
"INSERT INTO waitlist (email, locale) SELECT $1, $2 \
WHERE NOT EXISTS (SELECT 1 FROM users WHERE email = $1) \
AND (SELECT count(*) FROM waitlist) < 10000 \
ON CONFLICT DO NOTHING",
)
.bind(&email)
.bind(&locale)
.execute(&state.db)
.await?;
Ok((StatusCode::ACCEPTED, Json(json!({ "ok": true }))))
}