Compare commits
20
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
cf4d419e52 | ||
|
|
d63cdf737a | ||
|
|
810de0cb24 | ||
|
|
4676f7860f | ||
|
|
e68f7407f3 | ||
|
|
1b768d558d | ||
|
|
ad436f786c | ||
|
|
16c40864bb | ||
|
|
a2649fddeb | ||
|
|
ffb6060cfa | ||
|
|
09fc1e62c7 | ||
|
|
f69f76a05a | ||
|
|
5071589bf9 | ||
|
|
cd2eb02d3d | ||
|
|
43e22e6768 | ||
|
|
1a75dec59a | ||
|
|
7f6f05150e | ||
|
|
b0e1270246 | ||
|
|
663ceaca16 | ||
|
|
2e2e4b113d |
@@ -134,7 +134,8 @@ jobs:
|
||||
docker images "$IMAGE_PREFIX-$svc" --format '{{.Repository}}:{{.Tag}}' | xargs -r docker rmi >/dev/null 2>&1 || true
|
||||
done
|
||||
docker image prune -f >/dev/null
|
||||
docker builder prune -af --filter until=72h >/dev/null || true
|
||||
# A size cap, not an age: a busy day builds tens of gigabytes.
|
||||
docker builder prune -af --max-used-space 10GB >/dev/null || true
|
||||
|
||||
deploy:
|
||||
needs: build
|
||||
|
||||
Generated
+31
@@ -337,6 +337,15 @@ version = "2.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "217698eaf96b4a3f0bc4f3662aaa55bdf913cd54d7204591faa790070c6d0853"
|
||||
|
||||
[[package]]
|
||||
name = "crossbeam-channel"
|
||||
version = "0.5.17"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "98b0cc327b5bc766e7fda9c9260cc0fa81b43a8e240440422dff70788e3f9ef1"
|
||||
dependencies = [
|
||||
"crossbeam-utils",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "crossbeam-queue"
|
||||
version = "0.3.14"
|
||||
@@ -1853,8 +1862,11 @@ name = "service-kit"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"http",
|
||||
"tokio",
|
||||
"tower-http",
|
||||
"tracing",
|
||||
"tracing-appender",
|
||||
"tracing-subscriber",
|
||||
]
|
||||
|
||||
@@ -2197,6 +2209,12 @@ dependencies = [
|
||||
"cc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "symlink"
|
||||
version = "0.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a7973cce6668464ea31f176d85b13c7ab3bba2cb3b77a2ed26abd7801688010a"
|
||||
|
||||
[[package]]
|
||||
name = "syn"
|
||||
version = "2.0.119"
|
||||
@@ -2421,6 +2439,19 @@ dependencies = [
|
||||
"tracing-core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tracing-appender"
|
||||
version = "0.2.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "050686193eb999b4bb3bc2acfa891a13da00f79734704c4b8b4ef1a10b368a3c"
|
||||
dependencies = [
|
||||
"crossbeam-channel",
|
||||
"symlink",
|
||||
"thiserror",
|
||||
"time",
|
||||
"tracing-subscriber",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tracing-attributes"
|
||||
version = "0.1.31"
|
||||
|
||||
@@ -53,6 +53,7 @@ tokio = { version = "1", features = ["macros", "rt-multi-thread", "net", "signal
|
||||
tower-http = { version = "0.6", features = ["trace", "cors"] }
|
||||
tracing = "0.1"
|
||||
tracing-subscriber = { version = "0.3", features = ["env-filter", "json"] }
|
||||
tracing-appender = "0.2"
|
||||
|
||||
[profile.release]
|
||||
lto = "thin"
|
||||
|
||||
@@ -117,6 +117,67 @@ pub fn spread(id: &str) -> Option<&'static Spread> {
|
||||
SPREADS.iter().find(|s| s.id == id)
|
||||
}
|
||||
|
||||
/// What the reading is about: it steers how the cards are read.
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub struct Topic {
|
||||
pub id: &'static str,
|
||||
pub name: &'static str,
|
||||
/// The instruction for the model (Hungarian, English).
|
||||
pub focus: (&'static str, &'static str),
|
||||
}
|
||||
|
||||
pub const TOPICS: [Topic; 4] = [
|
||||
Topic {
|
||||
id: "general",
|
||||
name: "Általános",
|
||||
focus: (
|
||||
"Általános jóslás: az olvasó élete egészére vonatkoztasd a lapokat.",
|
||||
"A general reading: relate the cards to the reader's life as a whole.",
|
||||
),
|
||||
},
|
||||
Topic {
|
||||
id: "love",
|
||||
name: "Párkapcsolat",
|
||||
focus: (
|
||||
"Párkapcsolati jóslás: minden lapot a szerelem, a vonzalom, a közelség, a bizalom és a kommunikáció \
|
||||
szemszögéből olvass, akár van kapcsolata az olvasónak, akár keres. Ne feltételezd a partner nemét, és ne \
|
||||
jósolj szakítást, hűtlenséget vagy azt, hogy valaki biztosan visszatér.",
|
||||
"A relationship reading: read every card through love, attraction, closeness, trust and communication, \
|
||||
whether the reader is in a relationship or looking for one. Do not assume the partner's gender, and do \
|
||||
not predict a break-up, infidelity or that someone will surely come back.",
|
||||
),
|
||||
},
|
||||
Topic {
|
||||
id: "work",
|
||||
name: "Munka és hivatás",
|
||||
focus: (
|
||||
"Munka és hivatás: a lapokat a munka, a hivatás, a tanulás, a munkahelyi kapcsolatok és a fejlődés \
|
||||
szemszögéből olvasd. Ne adj pénzügyi vagy jogi tanácsot, és ne jósolj elbocsátást vagy anyagi \
|
||||
nyereséget, veszteséget.",
|
||||
"Work and calling: read the cards through work, vocation, learning, relationships at work and growth. \
|
||||
Give no financial or legal advice, and do not predict dismissal or financial gains or losses.",
|
||||
),
|
||||
},
|
||||
Topic {
|
||||
id: "self",
|
||||
name: "Önismeret",
|
||||
focus: (
|
||||
"Önismeret: a lapokat a belső világ, az érzelmek, a minták és a lelki fejlődés szemszögéből olvasd; a \
|
||||
külső események helyett arra figyelj, mit tanulhat az olvasó önmagáról.",
|
||||
"Self-knowledge: read the cards through the inner world, feelings, patterns and inner growth; rather \
|
||||
than outer events, focus on what the reader can learn about themselves.",
|
||||
),
|
||||
},
|
||||
];
|
||||
|
||||
/// A topic by id (`None`, and readings from before topics: general).
|
||||
pub fn topic(id: Option<&str>) -> Option<&'static Topic> {
|
||||
match id {
|
||||
None => TOPICS.first(),
|
||||
Some(id) => TOPICS.iter().find(|t| t.id == id),
|
||||
}
|
||||
}
|
||||
|
||||
/// The Hungarian name of a zodiac sign as the charts store it ("cancer").
|
||||
pub fn sign_hu(sign: &str) -> &'static str {
|
||||
match sign.to_ascii_lowercase().as_str() {
|
||||
@@ -142,6 +203,7 @@ pub fn sign_hu(sign: &str) -> &'static str {
|
||||
/// The cards are in the order of the spread's positions.
|
||||
pub struct Reading<'a> {
|
||||
pub spread: &'static Spread,
|
||||
pub topic: &'static Topic,
|
||||
pub question: Option<&'a str>,
|
||||
/// (card, reversed) per position.
|
||||
pub cards: Vec<(&'static Card, bool)>,
|
||||
@@ -171,6 +233,7 @@ impl<'a> Reading<'a> {
|
||||
let text = |k: &str| value[k].as_str().map(str::trim).filter(|s| !s.is_empty());
|
||||
Ok(Self {
|
||||
spread,
|
||||
topic: topic(text("topic")).ok_or("unknown topic")?,
|
||||
question: text("question"),
|
||||
cards,
|
||||
sun: text("sun"),
|
||||
@@ -284,12 +347,18 @@ pub fn build_tarot(language: &str, reading: &Reading) -> Prompt {
|
||||
let hu = language == "hu";
|
||||
let mut user = String::new();
|
||||
let none = if hu { "nincs megadva" } else { "not given" };
|
||||
user.push_str(&format!(
|
||||
"{}: {}. {}\n\n",
|
||||
if hu { "Téma" } else { "Topic" },
|
||||
reading.topic.name,
|
||||
if hu { reading.topic.focus.0 } else { reading.topic.focus.1 },
|
||||
));
|
||||
match reading.question {
|
||||
Some(q) => user.push_str(&format!("{}: {}\n\n", if hu { "A kérdés" } else { "The question" }, q.trim())),
|
||||
None => user.push_str(if hu {
|
||||
"Nincs konkrét kérdés: az olvasó a jelenlegi életszakaszára kér útmutatást.\n\n"
|
||||
"Nincs konkrét kérdés: az olvasó a témában a jelenlegi életszakaszára kér útmutatást.\n\n"
|
||||
} else {
|
||||
"No specific question: the reader asks for guidance about their present phase of life.\n\n"
|
||||
"No specific question: the reader asks for guidance on the topic in their present phase of life.\n\n"
|
||||
}),
|
||||
}
|
||||
let sign = |s: Option<&str>| {
|
||||
@@ -369,6 +438,8 @@ mod tests {
|
||||
"sun": "cancer", "moon": "pisces", "ascendant": null});
|
||||
let reading = Reading::parse(&value).unwrap();
|
||||
let prompt = build_tarot("hu", &reading);
|
||||
// Readings without a topic (the first ones) are general.
|
||||
assert!(prompt.user.starts_with("Téma: Általános."));
|
||||
assert!(prompt.user.contains("A kérdés: Merre induljak tovább?"));
|
||||
assert!(prompt.user.contains("Nap: Rák, Hold: Halak, Aszcendens: nincs megadva"));
|
||||
assert!(prompt.user.contains("2. Jelenlegi fókusz"));
|
||||
@@ -380,6 +451,15 @@ mod tests {
|
||||
let english = build_tarot("en", &reading);
|
||||
assert!(english.user.contains("Sun: Cancer") && english.system.contains("English"));
|
||||
|
||||
let mut love = value.clone();
|
||||
love["topic"] = json!("love");
|
||||
let prompt = build_tarot("hu", &Reading::parse(&love).unwrap());
|
||||
assert!(
|
||||
prompt.user.starts_with("Téma: Párkapcsolat.") && prompt.user.contains("Ne feltételezd a partner nemét")
|
||||
);
|
||||
love["topic"] = json!("pénz");
|
||||
assert!(Reading::parse(&love).is_err());
|
||||
|
||||
let wrong = json!({"spread": "daily", "cards": [{"card": "major-0"}, {"card": "major-1"}]});
|
||||
assert!(Reading::parse(&wrong).is_err());
|
||||
assert!(Reading::parse(&json!({"spread": "daily", "cards": [{"card": "nincs"}]})).is_err());
|
||||
|
||||
@@ -0,0 +1,4 @@
|
||||
-- When the worker asked Billingo for the invoice. Set before the request: if
|
||||
-- the answer is lost (a timeout after Billingo made it), the next attempt
|
||||
-- looks the invoice up instead of making a second one.
|
||||
ALTER TABLE invoices ADD COLUMN document_requested_at timestamptz;
|
||||
@@ -11,3 +11,6 @@ anyhow.workspace = true
|
||||
tokio.workspace = true
|
||||
tracing.workspace = true
|
||||
tracing-subscriber.workspace = true
|
||||
tracing-appender.workspace = true
|
||||
tower-http.workspace = true
|
||||
http = "1"
|
||||
|
||||
@@ -3,24 +3,215 @@
|
||||
//! Environment:
|
||||
//! * `BIND_ADDR` listen address (each service has its own default)
|
||||
//! * `LOG_FORMAT` `text` (default) or `json`; `RUST_LOG` sets the level
|
||||
//! * `LOG_DIR` also write the log there, as JSON, one file a UTC day
|
||||
//! (`<LOG_NAME>/<LOG_NAME>.YYYY-MM-DD.log`), keeping `LOG_KEEP_DAYS`
|
||||
//! (default 30) files of at most `LOG_MAX_DAY_MB` (default 50) each
|
||||
//! * `LOG_NAME` the folder and file name (default: the service's name)
|
||||
|
||||
use std::net::SocketAddr;
|
||||
use std::time::Duration;
|
||||
|
||||
use anyhow::Context;
|
||||
|
||||
/// Initializes `tracing` from `RUST_LOG` and `LOG_FORMAT`.
|
||||
pub fn init_logging() {
|
||||
use tracing_subscriber::EnvFilter;
|
||||
let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info,tower_http=info"));
|
||||
let builder = tracing_subscriber::fmt().with_env_filter(filter);
|
||||
/// Days of log files kept in `LOG_DIR` by default.
|
||||
const LOG_KEEP_DAYS: usize = 30;
|
||||
/// At most this many megabytes of log a day per service by default.
|
||||
const LOG_MAX_DAY_MB: u64 = 50;
|
||||
|
||||
/// Keeps the background log writer alive: hold it until `main` returns, so
|
||||
/// the last lines reach the file.
|
||||
#[must_use = "the log files stop being written when this is dropped"]
|
||||
pub struct LogGuard(#[allow(dead_code)] Option<tracing_appender::non_blocking::WorkerGuard>);
|
||||
|
||||
/// Logging for a one-off command: the console only, never the log files.
|
||||
pub fn init_console_logging() {
|
||||
use tracing_subscriber::layer::SubscriberExt;
|
||||
use tracing_subscriber::util::SubscriberInitExt;
|
||||
tracing_subscriber::registry().with(env_filter()).with(console_layer()).init();
|
||||
}
|
||||
|
||||
fn env_filter() -> tracing_subscriber::EnvFilter {
|
||||
tracing_subscriber::EnvFilter::try_from_default_env()
|
||||
.unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("info,tower_http=info"))
|
||||
}
|
||||
|
||||
fn console_layer<S>() -> Box<dyn tracing_subscriber::Layer<S> + Send + Sync>
|
||||
where
|
||||
S: tracing::Subscriber + for<'a> tracing_subscriber::registry::LookupSpan<'a>,
|
||||
{
|
||||
use tracing_subscriber::{Layer, fmt};
|
||||
if std::env::var("LOG_FORMAT").is_ok_and(|f| f.eq_ignore_ascii_case("json")) {
|
||||
builder.json().init();
|
||||
fmt::layer().json().boxed()
|
||||
} else {
|
||||
builder.init();
|
||||
fmt::layer().boxed()
|
||||
}
|
||||
}
|
||||
|
||||
/// A whole number from the environment; a value that is not one is reported.
|
||||
fn env_number<T: std::str::FromStr>(name: &str, default: T, problems: &mut Vec<String>) -> T {
|
||||
match std::env::var(name) {
|
||||
Ok(raw) if !raw.trim().is_empty() => raw.trim().parse().unwrap_or_else(|_| {
|
||||
problems.push(format!("{name}={raw} is not a whole number; using the default"));
|
||||
default
|
||||
}),
|
||||
_ => default,
|
||||
}
|
||||
}
|
||||
|
||||
/// Initializes `tracing` from `RUST_LOG` and `LOG_FORMAT`, and the log files
|
||||
/// in `LOG_DIR`, so the log outlives the container: each service writes its
|
||||
/// own folder `LOG_DIR/<name>/` (`<name>` = `LOG_NAME`, else `name`), one
|
||||
/// file a UTC day, keeping `LOG_KEEP_DAYS` files (at least 2), at most
|
||||
/// `LOG_MAX_DAY_MB` megabytes a day.
|
||||
pub fn init_logging(name: &str) -> LogGuard {
|
||||
use tracing_subscriber::layer::SubscriberExt;
|
||||
use tracing_subscriber::util::SubscriberInitExt;
|
||||
use tracing_subscriber::{Layer, fmt};
|
||||
|
||||
let mut problems = Vec::new();
|
||||
let mut guard = None;
|
||||
let file = std::env::var("LOG_DIR").ok().filter(|d| !d.trim().is_empty()).and_then(|dir| {
|
||||
let name = std::env::var("LOG_NAME").ok().filter(|n| !n.trim().is_empty()).unwrap_or_else(|| name.to_string());
|
||||
let keep: usize = env_number("LOG_KEEP_DAYS", LOG_KEEP_DAYS, &mut problems);
|
||||
if keep < 2 {
|
||||
problems.push(format!("LOG_KEEP_DAYS={keep} would delete today's file on a restart; keeping 2 days"));
|
||||
}
|
||||
let max_mb: u64 = env_number("LOG_MAX_DAY_MB", LOG_MAX_DAY_MB, &mut problems);
|
||||
// Its own folder: the old-file cleanup takes every file whose name
|
||||
// starts with the prefix ("worker" would take "worker-ai" files too).
|
||||
let folder = std::path::Path::new(&dir).join(&name);
|
||||
let appender = std::fs::create_dir_all(&folder).map_err(|e| e.to_string()).and_then(|()| {
|
||||
tracing_appender::rolling::Builder::new()
|
||||
.rotation(tracing_appender::rolling::Rotation::DAILY)
|
||||
.filename_prefix(&name)
|
||||
.filename_suffix("log")
|
||||
.max_log_files(keep.max(2))
|
||||
.build(&folder)
|
||||
.map_err(|e| e.to_string())
|
||||
});
|
||||
match appender {
|
||||
Ok(appender) => {
|
||||
let (writer, g) = tracing_appender::non_blocking(DailyCap::new(appender, max_mb.max(1) * 1024 * 1024));
|
||||
guard = Some(g);
|
||||
Some(fmt::layer().json().with_ansi(false).with_writer(writer).boxed())
|
||||
}
|
||||
Err(e) => {
|
||||
problems
|
||||
.push(format!("cannot write the log files in {}: {e}; logging to stdout only", folder.display()));
|
||||
None
|
||||
}
|
||||
}
|
||||
});
|
||||
tracing_subscriber::registry().with(env_filter()).with(console_layer()).with(file).init();
|
||||
for problem in problems {
|
||||
tracing::warn!("{problem}");
|
||||
}
|
||||
LogGuard(guard)
|
||||
}
|
||||
|
||||
/// A daily size limit in front of the log file: past `limit` bytes in a UTC
|
||||
/// day the rest of that day's lines are dropped (after one note saying so),
|
||||
/// so a log storm cannot fill the disk.
|
||||
struct DailyCap<W> {
|
||||
inner: W,
|
||||
limit: u64,
|
||||
day: u64,
|
||||
written: u64,
|
||||
}
|
||||
|
||||
impl<W> DailyCap<W> {
|
||||
fn new(inner: W, limit: u64) -> Self {
|
||||
Self { inner, limit, day: utc_day(), written: 0 }
|
||||
}
|
||||
}
|
||||
|
||||
fn utc_day() -> u64 {
|
||||
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map_or(0, |d| d.as_secs() / 86_400)
|
||||
}
|
||||
|
||||
impl<W: std::io::Write> std::io::Write for DailyCap<W> {
|
||||
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
|
||||
let today = utc_day();
|
||||
if today != self.day {
|
||||
self.day = today;
|
||||
self.written = 0;
|
||||
}
|
||||
if self.written >= self.limit {
|
||||
return Ok(buf.len());
|
||||
}
|
||||
self.written += buf.len() as u64;
|
||||
if self.written >= self.limit {
|
||||
let note = format!(
|
||||
"{{\"level\":\"WARN\",\"fields\":{{\"message\":\"daily log limit of {} MB reached; the rest of today is only on stdout\"}}}}\n",
|
||||
self.limit / 1024 / 1024
|
||||
);
|
||||
self.inner.write_all(buf)?;
|
||||
self.inner.write_all(note.as_bytes())?;
|
||||
return Ok(buf.len());
|
||||
}
|
||||
self.inner.write(buf)
|
||||
}
|
||||
|
||||
fn flush(&mut self) -> std::io::Result<()> {
|
||||
self.inner.flush()
|
||||
}
|
||||
}
|
||||
|
||||
/// The request log of an HTTP service (`TraceLayer::make_span_with` and
|
||||
/// `on_response`): the Docker health check stays out of it unless it fails,
|
||||
/// and e-mail addresses and tokens in the path are masked (the log is kept).
|
||||
#[derive(Debug, Clone, Copy, Default)]
|
||||
pub struct RequestLog;
|
||||
|
||||
impl<B> tower_http::trace::MakeSpan<B> for RequestLog {
|
||||
fn make_span(&mut self, request: &http::Request<B>) -> tracing::Span {
|
||||
let path = request.uri().path();
|
||||
if path == "/healthz" {
|
||||
return tracing::Span::none();
|
||||
}
|
||||
tracing::info_span!("request", method = %request.method(), path = %masked_path(path))
|
||||
}
|
||||
}
|
||||
|
||||
impl<B> tower_http::trace::OnResponse<B> for RequestLog {
|
||||
fn on_response(self, response: &http::Response<B>, latency: Duration, span: &tracing::Span) {
|
||||
// A health check (no span) that went well is not logged.
|
||||
if span.is_none() && response.status().is_success() {
|
||||
return;
|
||||
}
|
||||
let ms = latency.as_millis() as u64;
|
||||
let status = response.status().as_u16();
|
||||
if span.is_none() {
|
||||
tracing::warn!(path = "/healthz", status, latency_ms = ms, "health check failed");
|
||||
} else {
|
||||
tracing::info!(status, latency_ms = ms, "finished processing request");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The path with secrets masked: a segment holding an e-mail address, and a
|
||||
/// long one that is not a UUID (share slugs, invitation tokens). Queries are
|
||||
/// never logged.
|
||||
pub fn masked_path(path: &str) -> String {
|
||||
let uuid = |s: &str| {
|
||||
s.len() == 36
|
||||
&& s.char_indices()
|
||||
.all(|(i, c)| if [8, 13, 18, 23].contains(&i) { c == '-' } else { c.is_ascii_hexdigit() })
|
||||
};
|
||||
path.split('/')
|
||||
.map(|segment| {
|
||||
if segment.contains('@') || segment.contains("%40") {
|
||||
":email"
|
||||
} else if segment.len() >= 12 && !uuid(segment) {
|
||||
":token"
|
||||
} else {
|
||||
segment
|
||||
}
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
.join("/")
|
||||
}
|
||||
|
||||
/// Listen address from `BIND_ADDR`, or `default`.
|
||||
pub fn bind_addr(default: &str) -> anyhow::Result<SocketAddr> {
|
||||
let raw = std::env::var("BIND_ADDR").unwrap_or_else(|_| default.into());
|
||||
@@ -62,3 +253,34 @@ pub async fn shutdown_signal() {
|
||||
}
|
||||
tracing::info!("shutting down");
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::io::Write;
|
||||
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn secrets_in_paths_are_masked() {
|
||||
assert_eq!(masked_path("/v1/admin/waitlist/anna%40example.com"), "/v1/admin/waitlist/:email");
|
||||
assert_eq!(masked_path("/v1/public/shares/Ab3dEf6hIj9kLm2n/visit"), "/v1/public/shares/:token/visit");
|
||||
assert_eq!(masked_path("/v1/public/invites/k3jh4k5j6h7k8j9h0k1j2h3k"), "/v1/public/invites/:token");
|
||||
let id = "01a1f960-96cb-765f-899a-4d76b45b236e";
|
||||
assert_eq!(masked_path(&format!("/v1/tarot/readings/{id}")), format!("/v1/tarot/readings/{id}"));
|
||||
assert_eq!(masked_path("/v1/admin/prompts/forecast/hu"), "/v1/admin/prompts/forecast/hu");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_daily_cap_drops_the_rest_of_the_day() {
|
||||
let mut cap = DailyCap::new(Vec::new(), 10);
|
||||
cap.write_all(b"12345\n").unwrap();
|
||||
cap.write_all(b"67890\n").unwrap();
|
||||
cap.write_all(b"dropped\n").unwrap();
|
||||
let text = String::from_utf8(cap.inner.clone()).unwrap();
|
||||
assert!(text.starts_with("12345\n67890\n") && text.contains("daily log limit") && !text.contains("dropped"));
|
||||
// A new day starts again.
|
||||
cap.day -= 1;
|
||||
cap.write_all(b"next\n").unwrap();
|
||||
assert!(String::from_utf8(cap.inner).unwrap().ends_with("next\n"));
|
||||
}
|
||||
}
|
||||
|
||||
+7
-2
@@ -4,7 +4,8 @@
|
||||
{
|
||||
servers {
|
||||
# Cloudflare ranges (https://www.cloudflare.com/ips): the visitor's
|
||||
# address is taken from CF-Connecting-IP and passed on in X-Forwarded-For.
|
||||
# address ({client_ip}) is taken from CF-Connecting-IP, only when the
|
||||
# request comes from Cloudflare.
|
||||
trusted_proxies static 173.245.48.0/20 103.21.244.0/22 103.22.200.0/22 103.31.4.0/22 141.101.64.0/18 108.162.192.0/18 190.93.240.0/20 188.114.96.0/20 197.234.240.0/22 198.41.128.0/17 162.158.0.0/15 104.16.0.0/13 104.24.0.0/14 172.64.0.0/13 131.0.72.0/22 2400:cb00::/32 2606:4700::/32 2803:f800::/32 2405:b500::/32 2405:8100::/32 2a06:98c0::/29 2c0f:f248::/32
|
||||
client_ip_headers CF-Connecting-IP
|
||||
}
|
||||
@@ -14,7 +15,11 @@
|
||||
# No basic auth any more: the site is open, and new accounts need an
|
||||
# invitation (SIGNUP_MODE=invite in the backend).
|
||||
encode zstd gzip
|
||||
reverse_proxy frontend:3000
|
||||
reverse_proxy frontend:3000 {
|
||||
# The address the backend trusts (rate limits, share visits); it
|
||||
# overwrites whatever the browser sent in this header.
|
||||
header_up X-Real-IP {client_ip}
|
||||
}
|
||||
}
|
||||
|
||||
www.{$DOMAIN} {
|
||||
|
||||
+3
-1
@@ -82,7 +82,9 @@ A Google OAuth kliensnél a `https://sorsfonalak.hu` címet fel kell venni az en
|
||||
|
||||
## Üzemeltetés
|
||||
|
||||
- Naplók: `docker compose logs -f backend worker worker-ai`
|
||||
- Naplók élőben: `docker compose logs -f backend worker worker-ai` (ez a konténer újraindításáig/cseréjéig él).
|
||||
- Naplók utólag: a backend és a két worker JSON-sorokat ír a `logs` volume-ba is, szolgáltatásonként külön mappába, UTC-nap szerint új fájlba (`backend/backend.2026-11-20.log`, `worker/…`, `worker-ai/…`; a nap magyar idő szerint hajnali 1-2 órakor fordul). 30 napig maradnak meg, naponta legfeljebb 50 MB (`LOG_KEEP_DAYS`, `LOG_MAX_DAY_MB`, `LOG_DIR`, `LOG_NAME`); a kérések útvonalában az e-mail-címek és a tokenek maszkolva vannak. A fájlok helye: `docker volume inspect -f '{{.Mountpoint}}' sorsfonalak_logs`, például `grep -h '"level":"ERROR"' /var/lib/docker/volumes/sorsfonalak_logs/_data/backend/*.log | tail`. A Docker 30 másodpercenkénti `/healthz` ellenőrzése csak akkor kerül a naplóba, ha hibás.
|
||||
- Deploy és futó feladatok: leállításkor a worker nem vesz fel újat, a futókat befejezi (`SHUTDOWN_DRAIN_SECS`: `worker` 40 s, `worker-ai` 270 s, `stop_grace_period` 1, illetve 5 perc); ami addig nem készül el, visszakerül a sorba, a próbálkozás nem számít. Ha éppen elemzés készül, a deploy ennyivel tovább tarthat.
|
||||
- A worker két konténerben fut, ugyanabból az image-ből: a `worker` küldi az e-maileket és takarít (`WORKER_TASKS=email,cleanup`, ide kerülnek a további háttérfeladatok is), a `worker-ai` írja az elemzéseket és a válaszokat (`WORKER_TASKS=analyses`, gyors és lassú sáv). A sávok mérete a szerver `.env` fájljában állítható (`QUICK_CONCURRENCY`, `ANALYSIS_CONCURRENCY`).
|
||||
- Visszaállás korábbi verzióra: `.env`-ben `TAG=<régebbi hash>`, utána `docker compose up -d`
|
||||
- Mentés: naponta egy `pg_dump` a `/opt/sorsfonalak/backups` mappába, 14 napig megmarad. A mentéseket érdemes a szerverről is elvinni (DigitalOcean backup, vagy `rsync` otthonra).
|
||||
|
||||
@@ -81,6 +81,8 @@ services:
|
||||
HOROSCOPE_API_URL: http://horoscope-api:8080
|
||||
PUBLIC_BASE_URL: https://${DOMAIN}
|
||||
GOOGLE_CLIENT_IDS: ${GOOGLE_CLIENT_IDS:-}
|
||||
# Sign in with Apple: the Services ID (e.g. hu.sorsfonalak.web); empty: off.
|
||||
APPLE_CLIENT_IDS: ${APPLE_CLIENT_IDS:-}
|
||||
BOOTSTRAP_ADMIN_EMAILS: ${BOOTSTRAP_ADMIN_EMAILS:-}
|
||||
ANALYSIS_MODEL: ${ANALYSIS_MODEL:-}
|
||||
SUMMARY_MODEL: ${SUMMARY_MODEL:-}
|
||||
@@ -103,6 +105,9 @@ services:
|
||||
FREE_PERSON_SLOTS: ${FREE_PERSON_SLOTS:-0}
|
||||
# invite: new accounts need an invitation (admin page "Meghívók"); open: anyone.
|
||||
SIGNUP_MODE: ${SIGNUP_MODE:-invite}
|
||||
# The log also goes to the logs volume, one file a day, kept 30 days
|
||||
# (deploy/README.md: Logs).
|
||||
LOG_DIR: /logs
|
||||
# STRIPE_SECRET_KEY and STRIPE_WEBHOOK_SECRET (docs/fizetes.md): with them
|
||||
# packages can be bought (a test key: by admins only).
|
||||
env_file:
|
||||
@@ -114,6 +119,8 @@ services:
|
||||
horoscope-api:
|
||||
condition: service_healthy
|
||||
read_only: true
|
||||
volumes:
|
||||
- logs:/logs
|
||||
logging: *logging
|
||||
restart: unless-stopped
|
||||
|
||||
@@ -126,8 +133,11 @@ services:
|
||||
# SMTP_URL or the SES credentials come from .env.secrets (docs/levelkuldes.md);
|
||||
# listing them here with an empty default would override that file.
|
||||
SES_REGION: ${SES_REGION:-eu-central-1}
|
||||
MAIL_FROM: ${MAIL_FROM:-Sorsfonalak <hello@sorsfonalak.hu>}
|
||||
MAIL_FROM: ${MAIL_FROM:-Sorsfonalak <noreply@sorsfonalak.hu>}
|
||||
PUBLIC_BASE_URL: https://${DOMAIN}
|
||||
LOG_DIR: /logs
|
||||
# On a deploy the e-mails and invoices being sent finish first.
|
||||
SHUTDOWN_DRAIN_SECS: 40
|
||||
env_file:
|
||||
- path: .env.secrets
|
||||
required: false
|
||||
@@ -135,6 +145,9 @@ services:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
read_only: true
|
||||
volumes:
|
||||
- logs:/logs
|
||||
stop_grace_period: 1m
|
||||
logging: *logging
|
||||
restart: unless-stopped
|
||||
|
||||
@@ -148,6 +161,11 @@ services:
|
||||
QUICK_CONCURRENCY: ${QUICK_CONCURRENCY:-2}
|
||||
ANALYSIS_CONCURRENCY: ${ANALYSIS_CONCURRENCY:-4}
|
||||
PUBLIC_BASE_URL: https://${DOMAIN}
|
||||
LOG_DIR: /logs
|
||||
LOG_NAME: worker-ai
|
||||
# On a deploy the analyses being written finish first (a detailed one
|
||||
# takes a few minutes); what is not done by then goes back to the queue.
|
||||
SHUTDOWN_DRAIN_SECS: 270
|
||||
env_file:
|
||||
- path: .env.secrets
|
||||
required: false
|
||||
@@ -155,6 +173,9 @@ services:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
read_only: true
|
||||
volumes:
|
||||
- logs:/logs
|
||||
stop_grace_period: 5m
|
||||
logging: *logging
|
||||
restart: unless-stopped
|
||||
|
||||
@@ -177,5 +198,7 @@ services:
|
||||
|
||||
volumes:
|
||||
pgdata:
|
||||
# Backend and worker logs (backend.YYYY-MM-DD.log, worker…, worker-ai…).
|
||||
logs:
|
||||
caddy-data:
|
||||
caddy-config:
|
||||
|
||||
@@ -46,6 +46,7 @@ services:
|
||||
# Plain HTTP in development; leave the default (true) in production.
|
||||
COOKIE_SECURE: ${COOKIE_SECURE:-false}
|
||||
GOOGLE_CLIENT_IDS: ${GOOGLE_CLIENT_IDS:-}
|
||||
APPLE_CLIENT_IDS: ${APPLE_CLIENT_IDS:-}
|
||||
BOOTSTRAP_ADMIN_EMAILS: ${BOOTSTRAP_ADMIN_EMAILS:-}
|
||||
# Paid detailed analyses (empty: anthropic/claude-opus-5.5).
|
||||
ANALYSIS_MODEL: ${ANALYSIS_MODEL:-}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
# Kártyajóslás
|
||||
|
||||
A `/kartyajoslas` oldalon a felhasználó kirakást választ, opcionálisan kérdést ír (legfeljebb 300 karakter), és a legyezőbe terített, lefordított pakliból kiválasztja a lapokat. Ezután a lapok sorban felfordulnak, és elkészül a személyre szabott jóslás. A korábbi jóslások ugyanitt listázódnak, egyenként a `/kartyajoslas/{id}` oldalon nyithatók meg. A nyilvános példa a `/kartyajoslas/pelda` oldalon van (`src/content/tarot-pelda.json`).
|
||||
A `/kartyajoslas` oldalon a felhasználó témát (Általános, Párkapcsolat, Munka és hivatás, Önismeret; a téma szerinti olvasási szempont a promptba kerül, `TOPICS`) és kirakást választ, opcionálisan kérdést ír (legfeljebb 300 karakter), és a legyezőbe terített, lefordított pakliból kiválasztja a lapokat. Ezután a lapok sorban felfordulnak, és elkészül a személyre szabott jóslás. A korábbi jóslások ugyanitt listázódnak, egyenként a `/kartyajoslas/{id}` oldalon nyithatók meg. A nyilvános példaoldal (`/kartyajoslas/pelda`) két előre megírt jóslást mutat fülekkel, egy munkáról (3 lap) és egy párkapcsolatról (Képlet-kereszt, 5 lap). Mindkettőnél animáció játssza le a húzást: lapválasztás a legyezőből, kirakás, felfordítás, végül megjelenik a szöveg (`src/components/tarot/TarotDemo.tsx`, a szövegek: `src/content/tarot-pelda.json`). Mozgáscsökkentő beállításnál rögtön a végállapot látszik.
|
||||
|
||||
## Működés
|
||||
|
||||
|
||||
+1
-1
@@ -68,7 +68,7 @@ A droplet saját tűzfala (`sorsfonalak-fw`, DigitalOcean → Networking → Fir
|
||||
|
||||
## 6. Indítás
|
||||
|
||||
- A `.env` fájlban opcionális: `MAIL_FROM=Sorsfonalak <hello@sorsfonalak.hu>` (ez az alapérték is).
|
||||
- A `.env` fájlban opcionális: `MAIL_FROM=Sorsfonalak <noreply@sorsfonalak.hu>` (élesben ez van beállítva, és ez a deploy compose alapértéke is). Az Apple „Email Communication” beállításában ugyanez a cím van regisztrálva: ha változik, ott is át kell írni, különben az Apple-továbbítócímekre nem érkeznek meg a levelek.
|
||||
- Utána: `docker compose up -d worker`. A naplóban ennek kell megjelennie: `e-mail delivery enabled`, `via=Amazon SES eu-central-1:2587, credentials from …`.
|
||||
- Az eddig várakozó levelek ekkor kimennek. Ha ezt nem szeretnéd, előtte töröld őket: `DELETE FROM email_outbox WHERE sent_at IS NULL;`.
|
||||
- Hibaüzenetek a naplóban:
|
||||
|
||||
@@ -16,10 +16,13 @@ RUN --mount=type=cache,target=/usr/local/cargo/registry,sharing=locked \
|
||||
--mount=type=cache,target=/app/target,sharing=locked \
|
||||
cargo build --release --locked -p backend \
|
||||
&& cp target/release/backend /backend
|
||||
# The log directory (LOG_DIR); a volume mounted here takes over its owner.
|
||||
RUN mkdir /logs
|
||||
|
||||
# --- 2. runtime: the binary only (TLS roots are compiled in via webpki-roots) ---
|
||||
FROM scratch
|
||||
COPY --from=build /backend /backend
|
||||
COPY --from=build --chown=65532:65532 /logs /logs
|
||||
ENV BIND_ADDR=0.0.0.0:8081 \
|
||||
LOG_FORMAT=json \
|
||||
RUST_LOG=info
|
||||
|
||||
@@ -18,6 +18,7 @@ Felhasználók, belépés, mentett születési képletek, szinasztriák és megh
|
||||
| `FREE_PERSON_SLOTS` | `0` | ennyi személyt vehet fel csomag nélkül egy felhasználó |
|
||||
| `SIGNUP_MODE` | `invite` | `invite`: új fiók csak meghívóval jön létre (403 `not_invited`); `open`: bárki regisztrálhat |
|
||||
| `GOOGLE_CLIENT_IDS` | – | Google OAuth kliens-azonosító(k); üresen a Google-belépés ki van kapcsolva |
|
||||
| `APPLE_CLIENT_IDS` | – | Sign in with Apple: a Services ID(k) vesszővel elválasztva (pl. `hu.sorsfonalak.web`), az ID token `aud` mezője ezek egyike kell legyen; üresen az Apple-belépés ki van kapcsolva |
|
||||
| `BOOTSTRAP_ADMIN_EMAILS` | – | ezek a címek regisztrációkor vagy belépéskor admin szerepet kapnak (így lesz meg az első admin) |
|
||||
| `SUPPORTED_LOCALES` | `hu,en` | felület- és elemzésnyelvek; az első az alapértelmezett |
|
||||
| `ANALYSIS_MODEL` | `anthropic/claude-opus-5.5` | az elemzések, előrejelzések és válaszok alapmodellje, és a tartalék, ha a választott modell hibára fut |
|
||||
|
||||
@@ -75,6 +75,12 @@ pub struct Config {
|
||||
pub google_client_ids: Vec<String>,
|
||||
/// `GOOGLE_JWKS_URL` (default Google's certificate endpoint).
|
||||
pub google_jwks_url: String,
|
||||
/// `APPLE_CLIENT_IDS`: comma-separated Services IDs (e.g.
|
||||
/// `hu.sorsfonalak.web`) accepted as the ID token audience; empty
|
||||
/// disables Sign in with Apple.
|
||||
pub apple_client_ids: Vec<String>,
|
||||
/// `APPLE_JWKS_URL` (default Apple's key endpoint).
|
||||
pub apple_jwks_url: String,
|
||||
/// `BOOTSTRAP_ADMIN_EMAILS`: these users get the admin role when they
|
||||
/// register or log in (to create the first administrator).
|
||||
pub bootstrap_admin_emails: Vec<String>,
|
||||
@@ -197,6 +203,8 @@ impl Config {
|
||||
google_client_ids: list("GOOGLE_CLIENT_IDS"),
|
||||
google_jwks_url: var("GOOGLE_JWKS_URL")
|
||||
.unwrap_or_else(|| "https://www.googleapis.com/oauth2/v3/certs".into()),
|
||||
apple_client_ids: list("APPLE_CLIENT_IDS"),
|
||||
apple_jwks_url: var("APPLE_JWKS_URL").unwrap_or_else(|| "https://appleid.apple.com/auth/keys".into()),
|
||||
bootstrap_admin_emails: list("BOOTSTRAP_ADMIN_EMAILS").into_iter().map(|e| e.to_lowercase()).collect(),
|
||||
supported_locales,
|
||||
analysis_model: var("ANALYSIS_MODEL").unwrap_or_else(|| "anthropic/claude-opus-5.5".into()),
|
||||
@@ -240,6 +248,8 @@ impl Config {
|
||||
user_invites: true,
|
||||
referral_rewards: true,
|
||||
google_client_ids: vec!["test-client.apps.googleusercontent.com".into()],
|
||||
apple_client_ids: vec!["hu.sorsfonalak.test".into()],
|
||||
apple_jwks_url: google_jwks_url.clone(),
|
||||
google_jwks_url,
|
||||
bootstrap_admin_emails: vec!["admin@example.com".into()],
|
||||
supported_locales: vec!["hu".into(), "en".into()],
|
||||
|
||||
@@ -1,107 +0,0 @@
|
||||
//! Google Sign-In: verification of Google ID tokens.
|
||||
//!
|
||||
//! The frontend obtains an ID token with Google Identity Services (button or
|
||||
//! One Tap) and posts it to `POST /v1/auth/google`. The token is a JWT signed
|
||||
//! by Google; it is verified here against Google's published keys (JWKS,
|
||||
//! cached), the configured client ids (audience) and the issuer.
|
||||
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use jsonwebtoken::{Algorithm, DecodingKey, Validation, decode, decode_header};
|
||||
use serde::Deserialize;
|
||||
use tokio::sync::RwLock;
|
||||
|
||||
use crate::error::ApiError;
|
||||
|
||||
const ISSUERS: [&str; 2] = ["accounts.google.com", "https://accounts.google.com"];
|
||||
const JWKS_MAX_AGE: Duration = Duration::from_secs(3600);
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
pub struct GoogleClaims {
|
||||
/// Stable Google account id.
|
||||
pub sub: String,
|
||||
pub email: Option<String>,
|
||||
#[serde(default)]
|
||||
pub email_verified: bool,
|
||||
pub name: Option<String>,
|
||||
pub locale: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Deserialize)]
|
||||
struct Jwk {
|
||||
kid: String,
|
||||
n: String,
|
||||
e: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
struct JwkSet {
|
||||
keys: Vec<Jwk>,
|
||||
}
|
||||
|
||||
pub struct GoogleVerifier {
|
||||
client_ids: Vec<String>,
|
||||
jwks_url: String,
|
||||
http: reqwest::Client,
|
||||
cache: RwLock<Option<(Instant, Vec<Jwk>)>>,
|
||||
}
|
||||
|
||||
impl GoogleVerifier {
|
||||
pub fn new(client_ids: Vec<String>, jwks_url: String) -> Self {
|
||||
let http = reqwest::Client::builder().timeout(Duration::from_secs(10)).build().expect("static configuration");
|
||||
Self { client_ids, jwks_url, http, cache: RwLock::new(None) }
|
||||
}
|
||||
|
||||
pub fn enabled(&self) -> bool {
|
||||
!self.client_ids.is_empty()
|
||||
}
|
||||
|
||||
async fn fetch_keys(&self) -> Result<Vec<Jwk>, ApiError> {
|
||||
let set: JwkSet = self
|
||||
.http
|
||||
.get(&self.jwks_url)
|
||||
.send()
|
||||
.await
|
||||
.and_then(|r| r.error_for_status())
|
||||
.map_err(|e| ApiError::Internal(format!("fetching Google keys: {e}")))?
|
||||
.json()
|
||||
.await
|
||||
.map_err(|e| ApiError::Internal(format!("parsing Google keys: {e}")))?;
|
||||
Ok(set.keys)
|
||||
}
|
||||
|
||||
/// The key with `kid`; the key set is refetched when it is stale or the
|
||||
/// key is unknown (Google rotates its keys).
|
||||
async fn key(&self, kid: &str) -> Result<Jwk, ApiError> {
|
||||
if let Some((fetched, keys)) = self.cache.read().await.as_ref()
|
||||
&& fetched.elapsed() < JWKS_MAX_AGE
|
||||
&& let Some(k) = keys.iter().find(|k| k.kid == kid)
|
||||
{
|
||||
return Ok(k.clone());
|
||||
}
|
||||
let keys = self.fetch_keys().await?;
|
||||
let found = keys.iter().find(|k| k.kid == kid).cloned();
|
||||
*self.cache.write().await = Some((Instant::now(), keys));
|
||||
found.ok_or_else(|| ApiError::InvalidCredentials("the Google token is signed with an unknown key".into()))
|
||||
}
|
||||
|
||||
pub async fn verify(&self, id_token: &str) -> Result<GoogleClaims, ApiError> {
|
||||
if !self.enabled() {
|
||||
return Err(ApiError::Forbidden("Google login is not configured".into()));
|
||||
}
|
||||
let invalid =
|
||||
|e: jsonwebtoken::errors::Error| ApiError::InvalidCredentials(format!("invalid Google token: {e}"));
|
||||
let header = decode_header(id_token).map_err(invalid)?;
|
||||
if header.alg != Algorithm::RS256 {
|
||||
return Err(ApiError::InvalidCredentials("invalid Google token: unexpected algorithm".into()));
|
||||
}
|
||||
let kid = header.kid.ok_or_else(|| ApiError::InvalidCredentials("invalid Google token: no key id".into()))?;
|
||||
let jwk = self.key(&kid).await?;
|
||||
let key = DecodingKey::from_rsa_components(&jwk.n, &jwk.e).map_err(invalid)?;
|
||||
let mut validation = Validation::new(Algorithm::RS256);
|
||||
validation.set_audience(&self.client_ids);
|
||||
validation.set_issuer(&ISSUERS);
|
||||
validation.set_required_spec_claims(&["exp", "iss", "aud", "sub"]);
|
||||
Ok(decode::<GoogleClaims>(id_token, &key, &validation).map_err(invalid)?.claims)
|
||||
}
|
||||
}
|
||||
@@ -65,7 +65,11 @@ fn text(v: &Value) -> Option<String> {
|
||||
|
||||
impl Buyer {
|
||||
/// A company ("buying as a business") gives its name and tax id: a
|
||||
/// Hungarian tax number (`hu_tin`) is preferred to an EU VAT number.
|
||||
/// Hungarian tax number (`hu_tin`) is preferred to an EU VAT number. A
|
||||
/// Hungarian company with only an EU VAT number (`HU12345678`) is invoiced
|
||||
/// without a tax type number: Billingo takes only the full domestic
|
||||
/// number (`12345678-1-23`) for HAS_TAX_NUMBER; the EU number still goes
|
||||
/// on the invoice, in its comment (the worker adds it).
|
||||
pub fn from_stripe(details: &Value, fallback_email: Option<&str>) -> Self {
|
||||
let address = &details["address"];
|
||||
let tax_ids = details["tax_ids"].as_array().map(Vec::as_slice).unwrap_or_default();
|
||||
@@ -74,8 +78,8 @@ impl Buyer {
|
||||
let country = text(&address["country"]).unwrap_or_else(|| "HU".into()).to_uppercase();
|
||||
let tax_type = match (&tax_number, country.as_str()) {
|
||||
(_, c) if c != "HU" => "FOREIGN",
|
||||
(Some(_), _) => "HAS_TAX_NUMBER",
|
||||
(None, _) => "NO_TAX_NUMBER",
|
||||
(Some(_), _) if tax_id("hu_tin").is_some() => "HAS_TAX_NUMBER",
|
||||
_ => "NO_TAX_NUMBER",
|
||||
};
|
||||
let street = [text(&address["line1"]), text(&address["line2"])].into_iter().flatten().collect::<Vec<_>>();
|
||||
Self {
|
||||
@@ -176,6 +180,14 @@ mod tests {
|
||||
assert_eq!(company.email.as_deref(), Some("anna@example.com"));
|
||||
assert_eq!((company.tax_type, company.tax_number.as_deref()), ("HAS_TAX_NUMBER", Some("12345678-1-23")));
|
||||
|
||||
let eu_only = Buyer::from_stripe(
|
||||
&json!({"name": "Kovács Anna", "business_name": "Csillag Kft.", "address": {"country": "HU"},
|
||||
"tax_ids": [{"type": "eu_vat", "value": "HU12345678"}]}),
|
||||
None,
|
||||
);
|
||||
assert_eq!(eu_only.name, "Csillag Kft.");
|
||||
assert_eq!((eu_only.tax_type, eu_only.tax_number.as_deref()), ("NO_TAX_NUMBER", Some("HU12345678")));
|
||||
|
||||
let abroad = Buyer::from_stripe(&json!({"name": "Anna", "address": {"country": "at"}}), None);
|
||||
assert_eq!((abroad.country.as_str(), abroad.tax_type), ("AT", "FOREIGN"));
|
||||
}
|
||||
|
||||
@@ -12,9 +12,9 @@ mod birth_changes;
|
||||
mod config;
|
||||
mod credits;
|
||||
mod error;
|
||||
mod google;
|
||||
mod invoices;
|
||||
mod models;
|
||||
mod oidc;
|
||||
mod packages;
|
||||
mod persons;
|
||||
mod routes;
|
||||
@@ -32,7 +32,7 @@ use sqlx::PgPool;
|
||||
|
||||
use crate::auth::LoginLimiter;
|
||||
use crate::config::Config;
|
||||
use crate::google::GoogleVerifier;
|
||||
use crate::oidc::IdTokenVerifier;
|
||||
|
||||
const DEFAULT_BIND_ADDR: &str = "0.0.0.0:8081";
|
||||
|
||||
@@ -40,7 +40,8 @@ pub struct AppState {
|
||||
pub db: PgPool,
|
||||
pub config: Config,
|
||||
pub horoscope: HoroscopeClient,
|
||||
pub google: GoogleVerifier,
|
||||
pub google: IdTokenVerifier,
|
||||
pub apple: IdTokenVerifier,
|
||||
pub login_limiter: LoginLimiter,
|
||||
pub models: models::Catalog,
|
||||
pub stripe: stripe::Client,
|
||||
@@ -50,7 +51,8 @@ impl AppState {
|
||||
pub fn new(db: PgPool, config: Config) -> Self {
|
||||
Self {
|
||||
horoscope: HoroscopeClient::new(&config.horoscope_api_url),
|
||||
google: GoogleVerifier::new(config.google_client_ids.clone(), config.google_jwks_url.clone()),
|
||||
google: IdTokenVerifier::google(config.google_client_ids.clone(), config.google_jwks_url.clone()),
|
||||
apple: IdTokenVerifier::apple(config.apple_client_ids.clone(), config.apple_jwks_url.clone()),
|
||||
login_limiter: LoginLimiter::new(10, Duration::from_secs(15 * 60)),
|
||||
models: models::Catalog::new(&config.openrouter_models_url),
|
||||
stripe: stripe::Client::default(),
|
||||
@@ -66,12 +68,13 @@ async fn main() -> anyhow::Result<()> {
|
||||
if std::env::args().nth(1).as_deref() == Some("healthcheck") {
|
||||
return service_kit::healthcheck(addr);
|
||||
}
|
||||
service_kit::init_logging();
|
||||
let _log = service_kit::init_logging("backend");
|
||||
let config = Config::from_env()?;
|
||||
let pool = db::connect(&config.database_url).await.context("connecting to the database")?;
|
||||
db::migrate(&pool).await.context("running database migrations")?;
|
||||
tracing::info!(
|
||||
google_login = !config.google_client_ids.is_empty(),
|
||||
apple_login = !config.apple_client_ids.is_empty(),
|
||||
horoscope_api = %config.horoscope_api_url,
|
||||
"database ready"
|
||||
);
|
||||
|
||||
@@ -0,0 +1,139 @@
|
||||
//! Sign-in with Google and Apple: verification of their ID tokens.
|
||||
//!
|
||||
//! The frontend obtains an ID token (Google Identity Services, or Sign in with
|
||||
//! Apple JS) and posts it to `POST /v1/auth/google` / `/v1/auth/apple`. The
|
||||
//! token is a JWT signed by the provider; it is verified here against the
|
||||
//! provider's published keys (JWKS, cached), the configured client ids
|
||||
//! (audience: Google client ids, Apple Services IDs) and the issuer.
|
||||
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use jsonwebtoken::{Algorithm, DecodingKey, Validation, decode, decode_header};
|
||||
use serde::Deserialize;
|
||||
use tokio::sync::RwLock;
|
||||
|
||||
use crate::error::ApiError;
|
||||
|
||||
const GOOGLE_ISSUERS: &[&str] = &["accounts.google.com", "https://accounts.google.com"];
|
||||
const APPLE_ISSUERS: &[&str] = &["https://appleid.apple.com"];
|
||||
const JWKS_MAX_AGE: Duration = Duration::from_secs(3600);
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
pub struct IdClaims {
|
||||
/// Stable account id at the provider.
|
||||
pub sub: String,
|
||||
pub email: Option<String>,
|
||||
/// Apple sends it as a string ("true").
|
||||
#[serde(default, deserialize_with = "flexible_bool")]
|
||||
pub email_verified: bool,
|
||||
/// Google only; Apple gives the name to the frontend, at the first sign-in.
|
||||
pub name: Option<String>,
|
||||
pub locale: Option<String>,
|
||||
}
|
||||
|
||||
fn flexible_bool<'de, D: serde::Deserializer<'de>>(d: D) -> Result<bool, D::Error> {
|
||||
Ok(match serde_json::Value::deserialize(d)? {
|
||||
serde_json::Value::Bool(b) => b,
|
||||
serde_json::Value::String(s) => s == "true",
|
||||
_ => false,
|
||||
})
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Deserialize)]
|
||||
struct Jwk {
|
||||
kid: String,
|
||||
n: String,
|
||||
e: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
struct JwkSet {
|
||||
keys: Vec<Jwk>,
|
||||
}
|
||||
|
||||
pub struct IdTokenVerifier {
|
||||
/// "Google" or "Apple", for messages.
|
||||
provider: &'static str,
|
||||
issuers: &'static [&'static str],
|
||||
client_ids: Vec<String>,
|
||||
jwks_url: String,
|
||||
http: reqwest::Client,
|
||||
cache: RwLock<Option<(Instant, Vec<Jwk>)>>,
|
||||
}
|
||||
|
||||
impl IdTokenVerifier {
|
||||
fn new(
|
||||
provider: &'static str,
|
||||
issuers: &'static [&'static str],
|
||||
client_ids: Vec<String>,
|
||||
jwks_url: String,
|
||||
) -> Self {
|
||||
let http = reqwest::Client::builder().timeout(Duration::from_secs(10)).build().expect("static configuration");
|
||||
Self { provider, issuers, client_ids, jwks_url, http, cache: RwLock::new(None) }
|
||||
}
|
||||
|
||||
pub fn google(client_ids: Vec<String>, jwks_url: String) -> Self {
|
||||
Self::new("Google", GOOGLE_ISSUERS, client_ids, jwks_url)
|
||||
}
|
||||
|
||||
pub fn apple(client_ids: Vec<String>, jwks_url: String) -> Self {
|
||||
Self::new("Apple", APPLE_ISSUERS, client_ids, jwks_url)
|
||||
}
|
||||
|
||||
pub fn enabled(&self) -> bool {
|
||||
!self.client_ids.is_empty()
|
||||
}
|
||||
|
||||
async fn fetch_keys(&self) -> Result<Vec<Jwk>, ApiError> {
|
||||
let set: JwkSet = self
|
||||
.http
|
||||
.get(&self.jwks_url)
|
||||
.send()
|
||||
.await
|
||||
.and_then(|r| r.error_for_status())
|
||||
.map_err(|e| ApiError::Internal(format!("fetching {} keys: {e}", self.provider)))?
|
||||
.json()
|
||||
.await
|
||||
.map_err(|e| ApiError::Internal(format!("parsing {} keys: {e}", self.provider)))?;
|
||||
Ok(set.keys)
|
||||
}
|
||||
|
||||
/// The key with `kid`; the key set is refetched when it is stale or the
|
||||
/// key is unknown (the providers rotate their keys).
|
||||
async fn key(&self, kid: &str) -> Result<Jwk, ApiError> {
|
||||
if let Some((fetched, keys)) = self.cache.read().await.as_ref()
|
||||
&& fetched.elapsed() < JWKS_MAX_AGE
|
||||
&& let Some(k) = keys.iter().find(|k| k.kid == kid)
|
||||
{
|
||||
return Ok(k.clone());
|
||||
}
|
||||
let keys = self.fetch_keys().await?;
|
||||
let found = keys.iter().find(|k| k.kid == kid).cloned();
|
||||
*self.cache.write().await = Some((Instant::now(), keys));
|
||||
found.ok_or_else(|| {
|
||||
ApiError::InvalidCredentials(format!("the {} token is signed with an unknown key", self.provider))
|
||||
})
|
||||
}
|
||||
|
||||
pub async fn verify(&self, id_token: &str) -> Result<IdClaims, ApiError> {
|
||||
let provider = self.provider;
|
||||
if !self.enabled() {
|
||||
return Err(ApiError::Forbidden(format!("{provider} login is not configured")));
|
||||
}
|
||||
let invalid =
|
||||
|e: jsonwebtoken::errors::Error| ApiError::InvalidCredentials(format!("invalid {provider} token: {e}"));
|
||||
let header = decode_header(id_token).map_err(invalid)?;
|
||||
if header.alg != Algorithm::RS256 {
|
||||
return Err(ApiError::InvalidCredentials(format!("invalid {provider} token: unexpected algorithm")));
|
||||
}
|
||||
let kid =
|
||||
header.kid.ok_or_else(|| ApiError::InvalidCredentials(format!("invalid {provider} token: no key id")))?;
|
||||
let jwk = self.key(&kid).await?;
|
||||
let key = DecodingKey::from_rsa_components(&jwk.n, &jwk.e).map_err(invalid)?;
|
||||
let mut validation = Validation::new(Algorithm::RS256);
|
||||
validation.set_audience(&self.client_ids);
|
||||
validation.set_issuer(self.issuers);
|
||||
validation.set_required_spec_claims(&["exp", "iss", "aud", "sub"]);
|
||||
Ok(decode::<IdClaims>(id_token, &key, &validation).map_err(invalid)?.claims)
|
||||
}
|
||||
}
|
||||
@@ -183,6 +183,11 @@ pub(super) async fn queue(
|
||||
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?;
|
||||
|
||||
// One request at a time per user (a double click must not queue and pay
|
||||
// for the same analysis twice): the user row is locked until commit.
|
||||
let mut tx = state.db.begin().await?;
|
||||
sqlx::query("SELECT id FROM users WHERE id = $1 FOR UPDATE").bind(user).execute(&mut *tx).await?;
|
||||
|
||||
// Already requested for this chart/synastry: return it.
|
||||
let existing: Option<AnalysisRow> = sqlx::query_as(&format!(
|
||||
"SELECT {ANALYSIS_COLUMNS} FROM analyses \
|
||||
@@ -193,7 +198,7 @@ pub(super) async fn queue(
|
||||
.bind(synastry_id)
|
||||
.bind(cache_key)
|
||||
.bind(forecast_id)
|
||||
.fetch_optional(&state.db)
|
||||
.fetch_optional(&mut *tx)
|
||||
.await?;
|
||||
if let Some(row) = existing {
|
||||
return Ok((StatusCode::OK, row));
|
||||
@@ -214,7 +219,7 @@ pub(super) async fn queue(
|
||||
)
|
||||
.bind(cache_key)
|
||||
.bind(prompt_version)
|
||||
.fetch_optional(&state.db)
|
||||
.fetch_optional(&mut *tx)
|
||||
.await?;
|
||||
if let Some((content, input_tokens, output_tokens)) = cached {
|
||||
let row: AnalysisRow = sqlx::query_as(&insert)
|
||||
@@ -235,13 +240,13 @@ pub(super) async fn queue(
|
||||
.bind(OffsetDateTime::now_utc())
|
||||
.bind(forecast_id)
|
||||
.bind(fallback)
|
||||
.fetch_one(&state.db)
|
||||
.fetch_one(&mut *tx)
|
||||
.await?;
|
||||
tx.commit().await?;
|
||||
return Ok((StatusCode::CREATED, row));
|
||||
}
|
||||
|
||||
// New analysis: spend a unit and queue it for the worker.
|
||||
let mut tx = state.db.begin().await?;
|
||||
let row: AnalysisRow = sqlx::query_as(&insert)
|
||||
.bind(id)
|
||||
.bind(kind)
|
||||
|
||||
@@ -307,20 +307,78 @@ pub async fn google(
|
||||
WithRejection(Json(req), _): Body<GoogleRequest>,
|
||||
) -> ApiResult<impl IntoResponse> {
|
||||
let claims = state.google.verify(&req.id_token).await?;
|
||||
let signup = Signup {
|
||||
name: claims.name.clone(),
|
||||
locale: claims.locale.clone(),
|
||||
invite_token: req.invite_token,
|
||||
referral: req.referral,
|
||||
};
|
||||
social_login(&state, headers, jar, "google", claims, signup).await
|
||||
}
|
||||
|
||||
// --- Apple ------------------------------------------------------------------------------
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct AppleRequest {
|
||||
/// ID token (JWT) from Sign in with Apple JS.
|
||||
id_token: String,
|
||||
/// The name Apple gives the page at the first sign-in only (it is not in
|
||||
/// the token): used when the account is created.
|
||||
name: Option<String>,
|
||||
invite_token: Option<String>,
|
||||
referral: Option<String>,
|
||||
}
|
||||
|
||||
/// Logs in with Apple, like [`google`]. The address may be an Apple relay
|
||||
/// (`…@privaterelay.appleid.com`), which forwards our e-mails.
|
||||
pub async fn apple(
|
||||
State(state): St,
|
||||
headers: HeaderMap,
|
||||
jar: CookieJar,
|
||||
WithRejection(Json(req), _): Body<AppleRequest>,
|
||||
) -> ApiResult<impl IntoResponse> {
|
||||
let claims = state.apple.verify(&req.id_token).await?;
|
||||
let signup = Signup { name: req.name, locale: None, invite_token: req.invite_token, referral: req.referral };
|
||||
social_login(&state, headers, jar, "apple", claims, signup).await
|
||||
}
|
||||
|
||||
/// What a new account starts with.
|
||||
struct Signup {
|
||||
name: Option<String>,
|
||||
locale: Option<String>,
|
||||
invite_token: Option<String>,
|
||||
referral: Option<String>,
|
||||
}
|
||||
|
||||
/// Logs in with a verified provider identity: the linked user, else the user
|
||||
/// with the same (provider-verified) e-mail address, else a new user.
|
||||
async fn social_login(
|
||||
state: &AppState,
|
||||
headers: HeaderMap,
|
||||
jar: CookieJar,
|
||||
provider: &'static str,
|
||||
claims: crate::oidc::IdClaims,
|
||||
signup: Signup,
|
||||
) -> ApiResult<impl IntoResponse + use<>> {
|
||||
let email = match (claims.email.as_deref(), claims.email_verified) {
|
||||
(Some(e), true) => normalize_email(e)?,
|
||||
_ => return Err(ApiError::InvalidCredentials("the Google account has no verified e-mail address".into())),
|
||||
_ => {
|
||||
return Err(ApiError::InvalidCredentials(format!("the {provider} account has no verified e-mail address")));
|
||||
}
|
||||
};
|
||||
|
||||
let mut tx = state.db.begin().await?;
|
||||
let linked: Option<(Uuid,)> =
|
||||
sqlx::query_as("SELECT user_id FROM auth_identities WHERE provider = 'google' AND subject = $1")
|
||||
sqlx::query_as("SELECT user_id FROM auth_identities WHERE provider = $1 AND subject = $2")
|
||||
.bind(provider)
|
||||
.bind(&claims.sub)
|
||||
.fetch_optional(&mut *tx)
|
||||
.await?;
|
||||
let (user_id, created) = match linked {
|
||||
Some((id,)) => {
|
||||
sqlx::query("UPDATE auth_identities SET last_used_at = now() WHERE provider = 'google' AND subject = $1")
|
||||
sqlx::query("UPDATE auth_identities SET last_used_at = now() WHERE provider = $1 AND subject = $2")
|
||||
.bind(provider)
|
||||
.bind(&claims.sub)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
@@ -331,7 +389,24 @@ pub async fn google(
|
||||
sqlx::query_as("SELECT id FROM users WHERE email = $1").bind(&email).fetch_optional(&mut *tx).await?;
|
||||
let (id, created) = match existing {
|
||||
Some((id,)) => {
|
||||
// Google has verified the address, so it counts as verified here too.
|
||||
// An account whose address was never confirmed may have
|
||||
// been made by someone else with this address: its
|
||||
// password and sessions go, the provider has proven who
|
||||
// owns the address.
|
||||
let unverified: bool =
|
||||
sqlx::query_scalar("SELECT email_verified_at IS NULL FROM users WHERE id = $1 FOR UPDATE")
|
||||
.bind(id)
|
||||
.fetch_one(&mut *tx)
|
||||
.await?;
|
||||
if unverified {
|
||||
sqlx::query("DELETE FROM auth_identities WHERE user_id = $1 AND provider = 'password'")
|
||||
.bind(id)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
sqlx::query("DELETE FROM sessions WHERE user_id = $1").bind(id).execute(&mut *tx).await?;
|
||||
tracing::warn!(user = %id, provider, "unconfirmed password account taken over by its address's owner");
|
||||
}
|
||||
// The provider has verified the address, so it counts as verified here too.
|
||||
sqlx::query(
|
||||
"UPDATE users SET email_verified_at = COALESCE(email_verified_at, now()) WHERE id = $1",
|
||||
)
|
||||
@@ -341,9 +416,9 @@ pub async fn google(
|
||||
(id, false)
|
||||
}
|
||||
None => {
|
||||
super::invitations::admit(&state, &mut tx, &email, req.invite_token.as_deref()).await?;
|
||||
super::invitations::admit(state, &mut tx, &email, signup.invite_token.as_deref()).await?;
|
||||
let id = Uuid::now_v7();
|
||||
let locale = claims
|
||||
let locale = signup
|
||||
.locale
|
||||
.as_deref()
|
||||
.and_then(|l| l.split(['-', '_']).next())
|
||||
@@ -355,7 +430,7 @@ pub async fn google(
|
||||
)
|
||||
.bind(id)
|
||||
.bind(&email)
|
||||
.bind(clean_name(claims.name.clone()))
|
||||
.bind(clean_name(signup.name))
|
||||
.bind(locale)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
@@ -363,21 +438,27 @@ pub async fn google(
|
||||
&mut tx,
|
||||
id,
|
||||
&email,
|
||||
req.invite_token.as_deref(),
|
||||
signup.invite_token.as_deref(),
|
||||
state.config.free_person_slots,
|
||||
)
|
||||
.await?;
|
||||
super::shares::record_referral(&mut tx, state.config.referral_rewards, id, req.referral.as_deref())
|
||||
.await?;
|
||||
super::shares::record_referral(
|
||||
&mut tx,
|
||||
state.config.referral_rewards,
|
||||
id,
|
||||
signup.referral.as_deref(),
|
||||
)
|
||||
.await?;
|
||||
(id, true)
|
||||
}
|
||||
};
|
||||
sqlx::query(
|
||||
"INSERT INTO auth_identities (id, user_id, provider, subject, email, last_used_at) \
|
||||
VALUES ($1, $2, 'google', $3, $4, now())",
|
||||
VALUES ($1, $2, $3, $4, $5, now())",
|
||||
)
|
||||
.bind(Uuid::now_v7())
|
||||
.bind(id)
|
||||
.bind(provider)
|
||||
.bind(&claims.sub)
|
||||
.bind(&email)
|
||||
.execute(&mut *tx)
|
||||
@@ -386,11 +467,11 @@ pub async fn google(
|
||||
}
|
||||
};
|
||||
let mut user = load_user(&mut tx, user_id).await?;
|
||||
apply_bootstrap_admin(&state, &mut tx, &mut user).await?;
|
||||
apply_bootstrap_admin(state, &mut tx, &mut user).await?;
|
||||
tx.commit().await?;
|
||||
|
||||
let session = create_session(&state.db, &state.config, user.id, user_agent(&headers)).await?;
|
||||
Ok(login_response(&state, jar, &user, session, created))
|
||||
Ok(login_response(state, jar, &user, session, created))
|
||||
}
|
||||
|
||||
// --- logout -------------------------------------------------------------------------------
|
||||
|
||||
@@ -342,7 +342,9 @@ async fn corrected_birth(
|
||||
let (analysed, foreign_synastry): (bool, bool) = sqlx::query_as(
|
||||
"SELECT EXISTS (SELECT 1 FROM analyses WHERE chart_id = $1 AND kind <> 'summary' AND status <> 'failed') \
|
||||
OR EXISTS (SELECT 1 FROM analyses a JOIN synastries s ON s.id = a.synastry_id \
|
||||
WHERE (s.chart1_id = $1 OR s.chart2_id = $1) AND a.status <> 'failed'), \
|
||||
WHERE (s.chart1_id = $1 OR s.chart2_id = $1) AND a.status <> 'failed') \
|
||||
OR EXISTS (SELECT 1 FROM analyses a JOIN forecasts f ON f.id = a.forecast_id \
|
||||
WHERE f.chart_id = $1 AND a.status <> 'failed'), \
|
||||
EXISTS (SELECT 1 FROM synastries WHERE (chart1_id = $1 OR chart2_id = $1) AND owner_id <> $2)",
|
||||
)
|
||||
.bind(chart.id)
|
||||
|
||||
@@ -89,8 +89,8 @@ pub async fn mark_accepted(
|
||||
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)))",
|
||||
WHERE accepted_at IS NULL AND revoked_at IS NULL AND expires_at > now() \
|
||||
AND (email = $2 OR id IN (SELECT invitation_id FROM invitation_tokens WHERE token_hash = $3))",
|
||||
)
|
||||
.bind(user_id)
|
||||
.bind(email)
|
||||
@@ -603,10 +603,19 @@ pub async fn unsubscribe(
|
||||
.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",
|
||||
let revoked: Vec<Uuid> = sqlx::query_scalar(
|
||||
"UPDATE invitations SET revoked_at = now() WHERE email = $1 AND accepted_at IS NULL AND revoked_at IS NULL \
|
||||
RETURNING id",
|
||||
)
|
||||
.bind(&email)
|
||||
.fetch_all(&mut *tx)
|
||||
.await?;
|
||||
// Their packages go with them, as when an admin revokes an invitation.
|
||||
sqlx::query(
|
||||
"UPDATE promo_codes SET revoked_at = now() \
|
||||
WHERE invitation_id = ANY($1) AND redeemed_at IS NULL AND revoked_at IS NULL",
|
||||
)
|
||||
.bind(&revoked)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
sqlx::query("DELETE FROM waitlist WHERE email = $1").bind(&email).execute(&mut *tx).await?;
|
||||
@@ -630,12 +639,7 @@ pub async fn join_waitlist(
|
||||
let email = normalize_email(&req.email)?;
|
||||
let locale = validate_locale(&state, req.locale.as_deref())?;
|
||||
// Every sign-up sends an e-mail: a few per address, so the form cannot be used to flood someone.
|
||||
let ip = headers
|
||||
.get("x-forwarded-for")
|
||||
.and_then(|v| v.to_str().ok())
|
||||
.and_then(|v| v.split(',').next())
|
||||
.map(str::trim)
|
||||
.unwrap_or("unknown");
|
||||
let ip = super::client_ip(&headers).unwrap_or_else(|| "unknown".into());
|
||||
let key = format!("waitlist:{ip}");
|
||||
state.login_limiter.check(&key)?;
|
||||
let token = db::new_token();
|
||||
|
||||
@@ -122,9 +122,16 @@ pub async fn restart(
|
||||
.rows_affected()
|
||||
} else {
|
||||
let Some(row) = find_analysis(&state.db, id).await? else { continue };
|
||||
let Some(hash) = target_hash(&state.db, &row).await? else { continue };
|
||||
let (model, fallback) = models_for(&state, Kind::parse(&kind).unwrap_or(Kind::Natal)).await?;
|
||||
let (cache_key, prompt_version) = versions(&state, &kind, &hash, &model, &row.language).await?;
|
||||
let (model, fallback, cache_key, prompt_version) = if kind == "tarot" {
|
||||
// A tarot reading: the analysis model, the same cards, never cached.
|
||||
let (model, fallback) = models_for(&state, Kind::Natal).await?;
|
||||
(model, fallback, format!("tarot|{id}"), state.config.prompt_version.clone())
|
||||
} else {
|
||||
let Some(hash) = target_hash(&state.db, &row).await? else { continue };
|
||||
let (model, fallback) = models_for(&state, Kind::parse(&kind).unwrap_or(Kind::Natal)).await?;
|
||||
let (cache_key, prompt_version) = versions(&state, &kind, &hash, &model, &row.language).await?;
|
||||
(model, fallback, cache_key, prompt_version)
|
||||
};
|
||||
sqlx::query(
|
||||
"UPDATE analyses SET status = 'pending', model = $2, fallback_model = $3, on_fallback = false, \
|
||||
cache_key = $4, prompt_version = $5, attempts = 0, next_attempt_at = now(), started_at = NULL, \
|
||||
|
||||
@@ -36,8 +36,7 @@ use axum::{Json, Router};
|
||||
use axum_extra::extract::WithRejection;
|
||||
use serde_json::{Value, json};
|
||||
use tower_http::cors::{AllowOrigin, CorsLayer};
|
||||
use tower_http::trace::{DefaultMakeSpan, DefaultOnResponse, TraceLayer};
|
||||
use tracing::Level;
|
||||
use tower_http::trace::TraceLayer;
|
||||
use uuid::Uuid;
|
||||
|
||||
use crate::AppState;
|
||||
@@ -58,6 +57,15 @@ where
|
||||
serde::Deserialize::deserialize(d).map(Some)
|
||||
}
|
||||
|
||||
/// The visitor's address from `X-Real-IP`: Caddy sets it (overwriting what
|
||||
/// the browser sent) from Cloudflare's `CF-Connecting-IP`, trusted only from
|
||||
/// Cloudflare's ranges, and the frontend's proxy passes it on. Not
|
||||
/// `X-Forwarded-For`, whose first entry the browser can write.
|
||||
pub(crate) fn client_ip(headers: &axum::http::HeaderMap) -> Option<String> {
|
||||
let ip = headers.get("x-real-ip")?.to_str().ok()?.trim();
|
||||
(!ip.is_empty()).then(|| ip.to_string())
|
||||
}
|
||||
|
||||
pub fn router(state: Arc<AppState>) -> Router {
|
||||
Router::new()
|
||||
.route("/healthz", get(health))
|
||||
@@ -67,6 +75,7 @@ pub fn router(state: Arc<AppState>) -> Router {
|
||||
.route("/v1/auth/register", post(auth::register))
|
||||
.route("/v1/auth/login", post(auth::login))
|
||||
.route("/v1/auth/google", post(auth::google))
|
||||
.route("/v1/auth/apple", post(auth::apple))
|
||||
.route("/v1/auth/logout", post(auth::logout))
|
||||
.route("/v1/auth/logout-all", post(auth::logout_all))
|
||||
.route("/v1/auth/verify-email", post(auth::verify_email))
|
||||
@@ -141,11 +150,8 @@ pub fn router(state: Arc<AppState>) -> Router {
|
||||
.route("/v1/admin/analyses/{id}/regenerate", post(analyses::regenerate))
|
||||
.route("/v1/admin/questions/{id}/regenerate", post(questions::regenerate))
|
||||
.layer(cors(&state.config.cors_allowed_origins))
|
||||
.layer(
|
||||
TraceLayer::new_for_http()
|
||||
.make_span_with(DefaultMakeSpan::new().level(Level::INFO))
|
||||
.on_response(DefaultOnResponse::new().level(Level::INFO)),
|
||||
)
|
||||
// The request log: masked paths, health checks only when they fail.
|
||||
.layer(TraceLayer::new_for_http().make_span_with(service_kit::RequestLog).on_response(service_kit::RequestLog))
|
||||
.with_state(state)
|
||||
}
|
||||
|
||||
@@ -168,6 +174,7 @@ async fn public_config(State(state): St) -> Json<Value> {
|
||||
let c = &state.config;
|
||||
Json(json!({
|
||||
"google_login": { "enabled": state.google.enabled(), "client_id": c.google_client_ids.first() },
|
||||
"apple_login": { "enabled": state.apple.enabled(), "client_id": c.apple_client_ids.first() },
|
||||
"locales": c.supported_locales,
|
||||
"password_login": c.password_login,
|
||||
"mock_payments": payments::method(c) == Some("mock"),
|
||||
|
||||
@@ -61,12 +61,7 @@ struct ShareRow {
|
||||
const SHARE_COLUMNS: &str = "id, owner_id, slug, kind, chart_id, synastry_id, analysis_id, title, show_birth_data, \
|
||||
view_count, created_at, revoked_at, owner_ip_hash";
|
||||
|
||||
/// The visitor's address: the first `X-Forwarded-For` entry (Caddy writes it
|
||||
/// from Cloudflare's, the frontend passes it on).
|
||||
fn client_ip(headers: &HeaderMap) -> Option<String> {
|
||||
let first = headers.get("x-forwarded-for")?.to_str().ok()?.split(',').next()?.trim();
|
||||
(!first.is_empty()).then(|| first.to_string())
|
||||
}
|
||||
use super::client_ip;
|
||||
|
||||
/// An address salted with the slug, so the stored value says nothing by itself.
|
||||
fn ip_hash(slug: &str, ip: &str) -> Vec<u8> {
|
||||
@@ -231,8 +226,9 @@ pub async fn revoke(State(state): St, auth: AuthUser, WithRejection(Path(id), _)
|
||||
// --- public view -------------------------------------------------------------------------------
|
||||
|
||||
fn public_chart_block(chart: &ChartRow, share: &ShareRow) -> Value {
|
||||
// Birth data only of the sharer's own chart, never of a partner's.
|
||||
let show = share.show_birth_data && chart.owner_id == share.owner_id;
|
||||
// Birth data only of the sharer's own chart, never of a partner's or of a
|
||||
// person they added (that is someone else's data).
|
||||
let show = share.show_birth_data && chart.owner_id == share.owner_id && chart.kind == "own";
|
||||
json!({ "label": chart.label, "chart": public_chart(&chart.result, show) })
|
||||
}
|
||||
|
||||
|
||||
@@ -469,10 +469,10 @@ pub async fn accept_invite(
|
||||
let my_chart = chart_or_primary(&state.db, req.chart_id, auth.id()).await?;
|
||||
let inviter_chart =
|
||||
find_chart(&state.db, invite.inviter_chart_id).await?.ok_or(ApiError::NotFound("invitation"))?;
|
||||
let (row, _) = compute_synastry(&state, invite.inviter_id, &inviter_chart, &my_chart).await?;
|
||||
let (row, created) = compute_synastry(&state, invite.inviter_id, &inviter_chart, &my_chart).await?;
|
||||
|
||||
let mut tx = state.db.begin().await?;
|
||||
sqlx::query(
|
||||
let accepted = sqlx::query(
|
||||
"UPDATE synastry_invites SET accepted_at = now(), accepted_by = $1, synastry_id = $2 \
|
||||
WHERE id = $3 AND accepted_at IS NULL",
|
||||
)
|
||||
@@ -480,7 +480,17 @@ pub async fn accept_invite(
|
||||
.bind(row.id)
|
||||
.bind(invite.id)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
.await?
|
||||
.rows_affected();
|
||||
if accepted == 0 {
|
||||
// Someone else accepted it at the same moment: the comparison made
|
||||
// for this attempt goes, the link is used up.
|
||||
drop(tx);
|
||||
if created {
|
||||
sqlx::query("DELETE FROM synastries WHERE id = $1").bind(row.id).execute(&state.db).await?;
|
||||
}
|
||||
return Err(ApiError::Gone("this invitation has already been accepted".into()));
|
||||
}
|
||||
let inviter: Option<db::User> = sqlx::query_as(&format!("SELECT {USER_COLUMNS} FROM users WHERE id = $1"))
|
||||
.bind(invite.inviter_id)
|
||||
.fetch_optional(&mut *tx)
|
||||
|
||||
@@ -69,6 +69,8 @@ impl ReadingRow {
|
||||
"status": self.status,
|
||||
"spread": self.tarot["spread"],
|
||||
"spread_name": spread.map(|s| s.name),
|
||||
"topic": tarot::topic(self.tarot["topic"].as_str()).map(|t| t.id),
|
||||
"topic_name": tarot::topic(self.tarot["topic"].as_str()).map(|t| t.name),
|
||||
"question": self.tarot["question"],
|
||||
"cards": cards,
|
||||
"content": self.content,
|
||||
@@ -147,6 +149,8 @@ pub async fn get_one(State(state): St, auth: AuthUser, WithRejection(Path(id), _
|
||||
#[serde(deny_unknown_fields)]
|
||||
pub struct NewReading {
|
||||
spread: String,
|
||||
/// `general` (the default), `love`, `work` or `self`.
|
||||
topic: Option<String>,
|
||||
question: Option<String>,
|
||||
}
|
||||
|
||||
@@ -157,6 +161,7 @@ pub async fn create(
|
||||
WithRejection(Json(req), _): Body<NewReading>,
|
||||
) -> ApiResult<(StatusCode, Json<Value>)> {
|
||||
let spread = tarot::spread(&req.spread).ok_or_else(|| ApiError::BadRequest("unknown spread".into()))?;
|
||||
let topic = tarot::topic(req.topic.as_deref()).ok_or_else(|| ApiError::BadRequest("unknown topic".into()))?;
|
||||
let question = req.question.map(|q| q.trim().replace("\r\n", "\n")).filter(|q| !q.is_empty());
|
||||
if question.as_ref().is_some_and(|q| q.chars().count() > TAROT_QUESTION_MAX_CHARS) {
|
||||
return Err(ApiError::BadRequest(format!(
|
||||
@@ -179,6 +184,7 @@ pub async fn create(
|
||||
let (sun, moon, ascendant) = big_three(&state, auth.id()).await?;
|
||||
let reading = json!({
|
||||
"spread": spread.id,
|
||||
"topic": topic.id,
|
||||
"question": question,
|
||||
"cards": draw(spread),
|
||||
"sun": sun,
|
||||
|
||||
@@ -195,6 +195,18 @@ fn google_token(sub: &str, email: &str, audience: &str) -> String {
|
||||
jsonwebtoken::encode(&header, &claims, &jsonwebtoken::EncodingKey::from_rsa_pem(GOOGLE_KEY_PEM).unwrap()).unwrap()
|
||||
}
|
||||
|
||||
fn apple_token(sub: &str, email: &str, audience: &str) -> String {
|
||||
let now = time::OffsetDateTime::now_utc().unix_timestamp();
|
||||
// Apple sends email_verified as a string and no name.
|
||||
let claims = json!({
|
||||
"iss": "https://appleid.apple.com", "aud": audience, "sub": sub, "email": email,
|
||||
"email_verified": "true", "is_private_email": "true", "iat": now, "exp": now + 600
|
||||
});
|
||||
let mut header = jsonwebtoken::Header::new(jsonwebtoken::Algorithm::RS256);
|
||||
header.kid = Some("test-key".into());
|
||||
jsonwebtoken::encode(&header, &claims, &jsonwebtoken::EncodingKey::from_rsa_pem(GOOGLE_KEY_PEM).unwrap()).unwrap()
|
||||
}
|
||||
|
||||
// --- test client -------------------------------------------------------------------------------
|
||||
|
||||
struct TestApp {
|
||||
@@ -418,14 +430,31 @@ async fn google_login_creates_links_and_rejects(pool: PgPool) {
|
||||
.await;
|
||||
assert_eq!((r.status, &r.body["created"]), (StatusCode::OK, &json!(false)));
|
||||
|
||||
// an existing password account with the same address gets Google linked
|
||||
// an existing, confirmed password account with the same address gets Google linked
|
||||
let token = app.register("anna@example.com", "Anna").await;
|
||||
sqlx::query("UPDATE users SET email_verified_at = now() WHERE email = 'anna@example.com'")
|
||||
.execute(&app.pool)
|
||||
.await
|
||||
.unwrap();
|
||||
let r = app
|
||||
.post("/v1/auth/google", None, json!({"id_token": google_token("g-2", "anna@example.com", GOOGLE_CLIENT)}))
|
||||
.await;
|
||||
assert_eq!((r.status, &r.body["created"]), (StatusCode::OK, &json!(false)));
|
||||
assert_eq!(app.get("/v1/me", Some(&token)).await.body["providers"], json!(["password", "google"]));
|
||||
|
||||
// an unconfirmed one may be someone else's: its password and sessions go
|
||||
let squatter = app.register("victim@example.com", "Valaki").await;
|
||||
let r = app
|
||||
.post("/v1/auth/google", None, json!({"id_token": google_token("g-4", "victim@example.com", GOOGLE_CLIENT)}))
|
||||
.await;
|
||||
assert_eq!(r.status, StatusCode::OK, "{}", r.body);
|
||||
let owner = r.body["session"]["token"].as_str().unwrap().to_string();
|
||||
assert_eq!(app.get("/v1/me", Some(&squatter)).await.status, StatusCode::UNAUTHORIZED);
|
||||
assert_eq!(app.get("/v1/me", Some(&owner)).await.body["providers"], json!(["google"]));
|
||||
let r =
|
||||
app.post("/v1/auth/login", None, json!({"email": "victim@example.com", "password": "titkos-jelszo-123"})).await;
|
||||
assert_eq!(r.status, StatusCode::UNAUTHORIZED);
|
||||
|
||||
let r = app
|
||||
.post("/v1/auth/google", None, json!({"id_token": google_token("g-3", "x@gmail.com", "other-client")}))
|
||||
.await;
|
||||
@@ -851,7 +880,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; 16] = [
|
||||
const PUBLIC_ROUTES: [&str; 17] = [
|
||||
"/healthz",
|
||||
// Stripe calls it; the signature proves it.
|
||||
"/v1/payments/stripe/webhook",
|
||||
@@ -860,6 +889,7 @@ const PUBLIC_ROUTES: [&str; 16] = [
|
||||
"/v1/auth/register",
|
||||
"/v1/auth/login",
|
||||
"/v1/auth/google",
|
||||
"/v1/auth/apple",
|
||||
"/v1/auth/verify-email",
|
||||
"/v1/auth/password-reset",
|
||||
"/v1/auth/password-reset/confirm",
|
||||
@@ -877,7 +907,7 @@ async fn a_visit_by_someone_else_earns_one_question_once(pool: PgPool) {
|
||||
let anna = app.register("anna@example.com", "Anna").await;
|
||||
let chart = app.chart(&anna, "Saját", true, "1990-03-15").await;
|
||||
let share = json!({"kind": "chart", "target_id": chart["id"]});
|
||||
let home = ("x-forwarded-for", "203.0.113.7");
|
||||
let home = ("x-real-ip", "203.0.113.7");
|
||||
let r = app.call_with("POST", "/v1/shares", Some(&anna), Some(share), &[home]).await;
|
||||
assert_eq!(r.status, StatusCode::CREATED, "{}", r.body);
|
||||
let visit = format!("/v1/public/shares/{}/visit", r.body["slug"].as_str().unwrap());
|
||||
@@ -886,7 +916,9 @@ async fn a_visit_by_someone_else_earns_one_question_once(pool: PgPool) {
|
||||
let before = me().await["analyses_left"]["question"].as_i64().unwrap();
|
||||
|
||||
// robots, a missing user agent, the sharer's address and the sharer do not count
|
||||
let elsewhere = ("x-forwarded-for", "198.51.100.1, 172.70.1.1");
|
||||
// A browser cannot pose as the sharer through X-Forwarded-For: only X-Real-IP
|
||||
// (set by Caddy) counts.
|
||||
let elsewhere = ("x-real-ip", "198.51.100.1");
|
||||
for (token, headers) in [
|
||||
(None, vec![("user-agent", "facebookexternalhit/1.1"), elsewhere]),
|
||||
(None, vec![elsewhere]),
|
||||
@@ -1955,6 +1987,18 @@ async fn admins_restart_open_generations_with_the_current_models(pool: PgPool) {
|
||||
(status.as_str(), model.as_str(), fallback, started, attempts),
|
||||
("pending", "anthropic/claude-test", None, None, 0)
|
||||
);
|
||||
// a stuck tarot reading restarts too
|
||||
app.add_own_units(&admin, "tarot", 1).await;
|
||||
let reading = app.post("/v1/tarot/readings", Some(&admin), json!({"spread": "daily"})).await;
|
||||
let reading_id = reading.body["id"].as_str().unwrap().to_string();
|
||||
sqlx::query("UPDATE analyses SET status = 'running', started_at = now() WHERE id = $1::uuid")
|
||||
.bind(&reading_id)
|
||||
.execute(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
let r = app.post("/v1/admin/jobs/restart", Some(&admin), json!({ "ids": [reading_id] })).await;
|
||||
assert_eq!(r.body["restarted"], 1, "{}", r.body);
|
||||
|
||||
// finished ones are left alone
|
||||
sqlx::query("UPDATE analyses SET status = 'done', content = '{}'").execute(&pool).await.unwrap();
|
||||
assert_eq!(app.post("/v1/admin/jobs/restart", Some(&admin), json!({})).await.body["restarted"], 0);
|
||||
@@ -2161,7 +2205,7 @@ async fn an_invitation_brings_its_package_and_codes_fill_up(pool: PgPool) {
|
||||
async fn the_waitlist_confirms_and_can_be_left(pool: PgPool) {
|
||||
let app = TestApp::with_config(pool.clone(), |c| c.signup_mode = crate::config::SignupMode::Invite).await;
|
||||
let admin = app.register("admin@example.com", "Admin").await;
|
||||
let from = |ip: &'static str| [("x-forwarded-for", ip)];
|
||||
let from = |ip: &'static str| [("x-real-ip", ip)];
|
||||
|
||||
// one confirmation per address, even when sent again
|
||||
for _ in 0..2 {
|
||||
@@ -2593,7 +2637,7 @@ async fn tarot_readings_draw_on_the_server_and_use_tarot_units(pool: PgPool) {
|
||||
let app = TestApp::new(pool.clone()).await;
|
||||
let anna = app.register("anna@example.com", "Anna").await;
|
||||
app.chart(&anna, "Saját", true, "1990-07-01").await;
|
||||
let body = json!({"spread": "trinity", "question": "Merre induljak tovább?"});
|
||||
let body = json!({"spread": "trinity", "topic": "love", "question": "Merre induljak tovább?"});
|
||||
// No units: a package or the addon is needed.
|
||||
let r = app.post("/v1/tarot/readings", Some(&anna), body.clone()).await;
|
||||
assert_eq!(r.status, StatusCode::PAYMENT_REQUIRED, "{}", r.body);
|
||||
@@ -2610,6 +2654,8 @@ async fn tarot_readings_draw_on_the_server_and_use_tarot_units(pool: PgPool) {
|
||||
|
||||
let r = app.post("/v1/tarot/readings", Some(&anna), json!({"spread": "nincs"})).await;
|
||||
assert_eq!(r.status, StatusCode::BAD_REQUEST);
|
||||
let r = app.post("/v1/tarot/readings", Some(&anna), json!({"spread": "daily", "topic": "pénz"})).await;
|
||||
assert_eq!(r.status, StatusCode::BAD_REQUEST);
|
||||
let long = "x".repeat(analysis_prompt::TAROT_QUESTION_MAX_CHARS + 1);
|
||||
let r = app.post("/v1/tarot/readings", Some(&anna), json!({"spread": "daily", "question": long})).await;
|
||||
assert_eq!(r.status, StatusCode::BAD_REQUEST);
|
||||
@@ -2618,6 +2664,7 @@ async fn tarot_readings_draw_on_the_server_and_use_tarot_units(pool: PgPool) {
|
||||
assert_eq!(r.status, StatusCode::ACCEPTED, "{}", r.body);
|
||||
assert_eq!(r.body["status"], "pending");
|
||||
assert_eq!(r.body["spread_name"], "Sorsfonalak hármas");
|
||||
assert_eq!((&r.body["topic"], &r.body["topic_name"]), (&json!("love"), &json!("Párkapcsolat")));
|
||||
assert_eq!(r.body["question"], "Merre induljak tovább?");
|
||||
let cards = r.body["cards"].as_array().unwrap();
|
||||
assert_eq!(cards.len(), 3);
|
||||
@@ -2670,3 +2717,93 @@ async fn tarot_readings_draw_on_the_server_and_use_tarot_units(pool: PgPool) {
|
||||
assert_eq!(r.status, StatusCode::NO_CONTENT, "{}", r.body);
|
||||
assert_eq!(count().await, 0);
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn apple_login_creates_links_and_rejects(pool: PgPool) {
|
||||
let app = TestApp::new(pool).await;
|
||||
let r = app.get("/v1/config", None).await;
|
||||
assert_eq!(r.body["apple_login"], json!({"enabled": true, "client_id": "hu.sorsfonalak.test"}));
|
||||
let relay = "x7k2p9@privaterelay.appleid.com";
|
||||
// The name comes from the page (Apple gives it at the first sign-in only).
|
||||
let r = app
|
||||
.post(
|
||||
"/v1/auth/apple",
|
||||
None,
|
||||
json!({"id_token": apple_token("a-1", relay, "hu.sorsfonalak.test"), "name": "Kovács Anna"}),
|
||||
)
|
||||
.await;
|
||||
assert_eq!(r.status, StatusCode::CREATED, "{}", r.body);
|
||||
assert_eq!((&r.body["created"], &r.body["user"]["display_name"]), (&json!(true), &json!("Kovács Anna")));
|
||||
assert_eq!(r.body["user"]["email"], relay);
|
||||
let r =
|
||||
app.post("/v1/auth/apple", None, json!({"id_token": apple_token("a-1", relay, "hu.sorsfonalak.test")})).await;
|
||||
assert_eq!((r.status, &r.body["created"]), (StatusCode::OK, &json!(false)));
|
||||
assert_eq!(r.body["user"]["display_name"], "Kovács Anna");
|
||||
|
||||
// the same address as a Google account: both log into one user
|
||||
let google = app
|
||||
.post("/v1/auth/google", None, json!({"id_token": google_token("g-9", "bela@example.com", GOOGLE_CLIENT)}))
|
||||
.await;
|
||||
let token = google.body["session"]["token"].as_str().unwrap().to_string();
|
||||
let r = app
|
||||
.post(
|
||||
"/v1/auth/apple",
|
||||
None,
|
||||
json!({"id_token": apple_token("a-2", "bela@example.com", "hu.sorsfonalak.test")}),
|
||||
)
|
||||
.await;
|
||||
assert_eq!((r.status, &r.body["created"]), (StatusCode::OK, &json!(false)));
|
||||
assert_eq!(app.get("/v1/me", Some(&token)).await.body["providers"], json!(["google", "apple"]));
|
||||
|
||||
// a Google token is no Apple token, nor one for another Services ID
|
||||
let r = app
|
||||
.post("/v1/auth/apple", None, json!({"id_token": google_token("g-1", "gabor@gmail.com", GOOGLE_CLIENT)}))
|
||||
.await;
|
||||
assert_eq!(r.status, StatusCode::UNAUTHORIZED);
|
||||
let r = app.post("/v1/auth/apple", None, json!({"id_token": apple_token("a-3", relay, "other.service")})).await;
|
||||
assert_eq!(r.status, StatusCode::UNAUTHORIZED);
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn apple_login_can_be_off(pool: PgPool) {
|
||||
let app = TestApp::with_config(pool, |c| c.apple_client_ids.clear()).await;
|
||||
assert_eq!(app.get("/v1/config", None).await.body["apple_login"]["enabled"], false);
|
||||
let r = app
|
||||
.post("/v1/auth/apple", None, json!({"id_token": apple_token("a-1", "a@b.hu", "hu.sorsfonalak.test")}))
|
||||
.await;
|
||||
assert_eq!(r.status, StatusCode::FORBIDDEN);
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn a_double_click_queues_and_pays_one_analysis(pool: PgPool) {
|
||||
let app = TestApp::new(pool.clone()).await;
|
||||
let anna = app.register("anna@example.com", "Anna").await;
|
||||
let chart = app.chart(&anna, "Saját", true, "1990-03-15").await;
|
||||
grant_units(&app, &anna, "natal", 2).await;
|
||||
let url = format!("/v1/charts/{}/analyses", chart["id"].as_str().unwrap());
|
||||
let (a, b) = tokio::join!(app.call("POST", &url, Some(&anna), None), app.call("POST", &url, Some(&anna), None));
|
||||
assert!(a.status.is_success() && b.status.is_success(), "{} {}", a.body, b.body);
|
||||
assert_eq!(a.body["id"], b.body["id"]);
|
||||
let count: i64 =
|
||||
sqlx::query_scalar("SELECT count(*) FROM analyses WHERE kind = 'natal'").fetch_one(&pool).await.unwrap();
|
||||
assert_eq!(count, 1);
|
||||
assert_eq!(app.get("/v1/me", Some(&anna)).await.body["analyses_left"]["natal"], 1);
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn a_paid_forecast_fixes_the_person(pool: PgPool) {
|
||||
let app = TestApp::new(pool).await;
|
||||
let anna = app.register("anna@example.com", "Anna").await;
|
||||
app.chart(&anna, "Saját", true, "1990-03-15").await;
|
||||
let bela = app.chart(&anna, "Béla", false, "1985-08-02").await;
|
||||
let bela_id = bela["id"].as_str().unwrap();
|
||||
let forecast = app.post(&format!("/v1/charts/{bela_id}/forecasts"), Some(&anna), json!({})).await;
|
||||
assert_eq!(forecast.status, StatusCode::CREATED, "{}", forecast.body);
|
||||
grant_units(&app, &anna, "forecast", 1).await;
|
||||
let id = forecast.body["id"].as_str().unwrap();
|
||||
let r = app.call("POST", &format!("/v1/forecasts/{id}/analyses"), Some(&anna), None).await;
|
||||
assert_eq!(r.status, StatusCode::ACCEPTED, "{}", r.body);
|
||||
let corrected = json!({"birth": {"date": "1985-08-03", "time": "10:00", "country": "HU", "place": "Szeged"}});
|
||||
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")));
|
||||
}
|
||||
|
||||
@@ -2,11 +2,16 @@ import Link from "next/link";
|
||||
|
||||
import { ChartWheel } from "@/components/ChartWheel";
|
||||
import { Rich } from "@/components/Rich";
|
||||
import { TarotCard, TarotCardBack } from "@/components/tarot/TarotCard";
|
||||
import { Logo, PublicHeader } from "@/components/SiteHeader";
|
||||
import { Waitlist } from "@/components/Waitlist";
|
||||
import example from "@/content/pelda.json";
|
||||
import { tarotCard } from "@/lib/tarot";
|
||||
import type { AnalysisContent, ChartResult } from "@/lib/types";
|
||||
|
||||
/** The cards fanned out next to the tarot line (after a card back). */
|
||||
const TAROT_CARDS = ["major-2", "major-17"].map((id) => tarotCard(id)).filter((c) => c !== undefined);
|
||||
|
||||
// A quiet starfield, the same on every render.
|
||||
const STARS = (() => {
|
||||
let seed = 7;
|
||||
@@ -81,8 +86,8 @@ export function Landing({ inviteOnly }: { inviteOnly: boolean }) {
|
||||
belőle. Megmutatjuk, mit hoz az éved, és mennyire illetek össze azzal, akit szeretsz.
|
||||
</p>
|
||||
<p className="ai-line lp-ai-line lp-rise lp-r3">
|
||||
Részletes elemzések a legfejlettebb AI-modellekkel: egy tapasztalt asztrológushoz közelítő mélység, töredék
|
||||
áron.
|
||||
Részletes, személyre szóló elemzések a legfejlettebb AI-modellekkel: percek alatt, egy személyes konzultáció
|
||||
árának töredékéért.
|
||||
</p>
|
||||
<div className="lp-actions lp-rise lp-r4">
|
||||
<Link href="/belepes" className="btn btn-primary lp-btn">
|
||||
@@ -137,7 +142,7 @@ export function Landing({ inviteOnly }: { inviteOnly: boolean }) {
|
||||
<div className="lp-intro">
|
||||
<span className="eyebrow">Miért más?</span>
|
||||
<h2 id="why-title" className="lp-h2">
|
||||
Egy asztrológus mélysége, töredék áron
|
||||
Alapos elemzés, töredék áron
|
||||
</h2>
|
||||
</div>
|
||||
<ul className="lp-why-grid">
|
||||
@@ -158,10 +163,10 @@ export function Landing({ inviteOnly }: { inviteOnly: boolean }) {
|
||||
<circle cx="12" cy="12" r="4" />
|
||||
<path d="M12 3v5M12 16v5M3 12h5M16 12h5" />
|
||||
</svg>
|
||||
<h3 className="lp-step-title">Asztrológusi mélység</h3>
|
||||
<h3 className="lp-step-title">Az egész képletet olvassa</h3>
|
||||
<p className="lp-small">
|
||||
A bolygókat jegyükben, házukban, fényszögeikben és uralkodóik láncolatában olvassa, a holdcsomópontokkal és
|
||||
az év tranzitjaival együtt, ahogy egy tapasztalt asztrológus is tenné.
|
||||
az év tranzitjaival együtt: nem egy-egy fényállást, hanem az összefüggéseket.
|
||||
</p>
|
||||
</li>
|
||||
<li className="card lp-why-card">
|
||||
@@ -378,6 +383,28 @@ export function Landing({ inviteOnly }: { inviteOnly: boolean }) {
|
||||
</div>
|
||||
</article>
|
||||
</div>
|
||||
|
||||
<article className="card lp-tarot" aria-labelledby="tarot-title">
|
||||
<div className="lp-tarot-cards" aria-hidden="true">
|
||||
<TarotCardBack />
|
||||
{TAROT_CARDS.map((card) => (
|
||||
<TarotCard key={card.id} card={card} />
|
||||
))}
|
||||
</div>
|
||||
<div className="lp-tarot-text">
|
||||
<span className="eyebrow">Kártyajóslás is</span>
|
||||
<h3 id="tarot-title" className="lp-tarot-title">
|
||||
Egy kérdés, néhány lap
|
||||
</h3>
|
||||
<p className="lp-small">
|
||||
Húzz lapot egy konkrét kérdésre: a kirakásodra és a képleted Napjára, Holdjára, Aszcendensére személyre
|
||||
szabott értelmezés készül. Néhány jóslás minden csomagban benne van.
|
||||
</p>
|
||||
</div>
|
||||
<Link href="/kartyajoslas/pelda" className="lp-tarot-link">
|
||||
Példajóslás →
|
||||
</Link>
|
||||
</article>
|
||||
</div>
|
||||
</section>
|
||||
|
||||
@@ -454,11 +481,9 @@ export function Landing({ inviteOnly }: { inviteOnly: boolean }) {
|
||||
<Logo />
|
||||
<nav aria-label="Lábléc" className="lp-footer-nav">
|
||||
<Link href="/pelda">Példaelemzés</Link>
|
||||
<Link href="/kartyajoslas/pelda">Példajóslás</Link>
|
||||
<Link href="/aszf">ÁSZF</Link>
|
||||
<Link href="/adatvedelem">Adatvédelem</Link>
|
||||
<Link href="/privacy" lang="en">
|
||||
Privacy Policy
|
||||
</Link>
|
||||
<Link href="/belepes">Belépés</Link>
|
||||
</nav>
|
||||
<span className="hint">© {new Date().getFullYear()} Sorsfonalak</span>
|
||||
|
||||
@@ -57,7 +57,10 @@ export default async function PrivacyPage() {
|
||||
</thead>
|
||||
<tbody>
|
||||
<tr>
|
||||
<td>Google-fiókod neve, e-mail-címe és azonosítója (belépéskor a Google adja át)</td>
|
||||
<td>
|
||||
Google- vagy Apple-fiókod neve, e-mail-címe és azonosítója (belépéskor a Google, illetve az Apple adja
|
||||
át)
|
||||
</td>
|
||||
<td>Fiókod létrehozása, belépés, kapcsolattartás</td>
|
||||
<td>Szerződés teljesítése (GDPR 6. cikk (1) b)</td>
|
||||
</tr>
|
||||
@@ -168,6 +171,13 @@ export default async function PrivacyPage() {
|
||||
</a>{" "}
|
||||
szabályzatnak, beleértve a „Limited Use” (korlátozott felhasználás) követelményeit.
|
||||
</p>
|
||||
<p>
|
||||
<strong>Belépés Apple-fiókkal:</strong> ha az „Apple-bejelentkezést” választod, az Apple a fiókod egyedi
|
||||
azonosítóját és az e-mail-címedet adja át, az első belépéskor a nevedet is. Ha az e-mail-címedet elrejted,
|
||||
egy Apple-továbbítócímet kapunk (<code>…@privaterelay.appleid.com</code>): az erre küldött leveleinket az Apple
|
||||
továbbítja hozzád. Ezeket ugyanarra és ugyanúgy használjuk, mint a Google-adatokat. A hozzáférést az Apple ID
|
||||
beállításaidban vonhatod vissza (Bejelentkezés és biztonság › Bejelentkezés az Apple-lel).
|
||||
</p>
|
||||
</section>
|
||||
|
||||
<section>
|
||||
|
||||
@@ -28,8 +28,10 @@ async function forward(req: NextRequest, ctx: { params: Promise<{ path: string[]
|
||||
const value = req.headers.get(name);
|
||||
if (value) headers.set(name, value);
|
||||
}
|
||||
const forwardedFor = req.headers.get("x-forwarded-for");
|
||||
if (forwardedFor) headers.set("x-forwarded-for", forwardedFor);
|
||||
// The visitor's address as Caddy set it (from Cloudflare's CF-Connecting-IP,
|
||||
// overwriting any the browser sent).
|
||||
const realIp = req.headers.get("x-real-ip");
|
||||
if (realIp) headers.set("x-real-ip", realIp);
|
||||
|
||||
let res: Response;
|
||||
try {
|
||||
|
||||
@@ -0,0 +1,152 @@
|
||||
"use client";
|
||||
|
||||
import Script from "next/script";
|
||||
import { useRouter } from "next/navigation";
|
||||
import { useState } from "react";
|
||||
|
||||
import { Waitlist } from "@/components/Waitlist";
|
||||
import { ApiError, api, errorText } from "@/lib/api";
|
||||
|
||||
/** The part of Sign in with Apple JS (appleid.auth.js) we use. */
|
||||
interface AppleSignInResponse {
|
||||
authorization: { id_token: string; code: string; state?: string };
|
||||
/** Only at the first sign-in of this Apple ID on the site. */
|
||||
user?: { email?: string; name?: { firstName?: string; lastName?: string } };
|
||||
}
|
||||
|
||||
declare global {
|
||||
interface Window {
|
||||
AppleID?: {
|
||||
auth: {
|
||||
init(options: { clientId: string; scope: string; redirectURI: string; state?: string; usePopup: boolean }): void;
|
||||
signIn(): Promise<AppleSignInResponse>;
|
||||
};
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
/** Apple's logo (Sign in with Apple guidelines: the logo left of the label). */
|
||||
function AppleMark() {
|
||||
return (
|
||||
<svg width="18" height="20" viewBox="0 0 17 20" aria-hidden="true" fill="currentColor">
|
||||
<path d="M13.77 10.62c-.02-2.2 1.8-3.26 1.88-3.31-1.03-1.5-2.62-1.7-3.18-1.73-1.35-.14-2.64.8-3.33.8-.69 0-1.74-.78-2.86-.76-1.47.02-2.83.86-3.59 2.17-1.53 2.65-.39 6.57 1.1 8.72.73 1.05 1.6 2.23 2.73 2.19 1.1-.04 1.51-.71 2.84-.71 1.32 0 1.7.71 2.86.69 1.18-.02 1.93-1.07 2.65-2.12.84-1.22 1.18-2.4 1.2-2.46-.03-.01-2.29-.88-2.3-3.48zM11.6 4.17c.6-.73 1.01-1.75.9-2.76-.87.04-1.92.58-2.54 1.31-.56.65-1.05 1.69-.92 2.68.97.08 1.96-.49 2.56-1.23z" />
|
||||
</svg>
|
||||
);
|
||||
}
|
||||
|
||||
/** The e-mail address inside Apple's ID token (only for the waitlist form; the backend verifies the token). */
|
||||
function tokenEmail(idToken: string): string {
|
||||
try {
|
||||
const part = idToken.split(".")[1].replace(/-/g, "+").replace(/_/g, "/");
|
||||
const bytes = Uint8Array.from(atob(part), (c) => c.charCodeAt(0));
|
||||
const email = JSON.parse(new TextDecoder().decode(bytes)).email;
|
||||
return typeof email === "string" ? email : "";
|
||||
} catch {
|
||||
return "";
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* "Continue with Apple": Apple's sign-in opens in a popup and returns an ID
|
||||
* token, which the backend verifies. Apple gives the name only at the first
|
||||
* sign-in, so it is sent along then (Hungarian order: family name first).
|
||||
*/
|
||||
export function AppleLogin({
|
||||
clientId,
|
||||
target,
|
||||
inviteToken = null,
|
||||
}: {
|
||||
clientId: string;
|
||||
target: string;
|
||||
inviteToken?: string | null;
|
||||
}) {
|
||||
const router = useRouter();
|
||||
const [ready, setReady] = useState(false);
|
||||
const [busy, setBusy] = useState(false);
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
const [uninvited, setUninvited] = useState<string | null>(null);
|
||||
|
||||
function loaded() {
|
||||
window.AppleID?.auth.init({
|
||||
clientId,
|
||||
scope: "name email",
|
||||
redirectURI: `${window.location.origin}/belepes`,
|
||||
usePopup: true,
|
||||
});
|
||||
setReady(true);
|
||||
}
|
||||
|
||||
async function signIn() {
|
||||
const apple = window.AppleID;
|
||||
if (!apple) return;
|
||||
setError(null);
|
||||
setUninvited(null);
|
||||
let response: AppleSignInResponse;
|
||||
try {
|
||||
response = await apple.auth.signIn();
|
||||
} catch (e) {
|
||||
// Closing the popup is not an error worth showing.
|
||||
const code = (e as { error?: string } | null)?.error;
|
||||
if (code !== "popup_closed_by_user" && code !== "user_cancelled_authorize") {
|
||||
setError("Az Apple-belépés nem sikerült. Próbáld újra.");
|
||||
}
|
||||
return;
|
||||
}
|
||||
setBusy(true);
|
||||
const name = [response.user?.name?.lastName, response.user?.name?.firstName].filter(Boolean).join(" ") || null;
|
||||
try {
|
||||
let referral: string | null = null;
|
||||
try {
|
||||
referral = localStorage.getItem("sf_ref");
|
||||
} catch {
|
||||
// storage blocked
|
||||
}
|
||||
await api("/auth/apple", {
|
||||
body: { id_token: response.authorization.id_token, name, invite_token: inviteToken, referral },
|
||||
});
|
||||
try {
|
||||
localStorage.removeItem("sf_ref");
|
||||
} catch {
|
||||
// storage blocked
|
||||
}
|
||||
router.replace(target);
|
||||
router.refresh();
|
||||
} catch (e) {
|
||||
if (e instanceof ApiError && e.code === "not_invited") setUninvited(tokenEmail(response.authorization.id_token));
|
||||
else setError(errorText(e));
|
||||
setBusy(false);
|
||||
}
|
||||
}
|
||||
|
||||
return (
|
||||
<div className="field">
|
||||
<Script
|
||||
src="https://appleid.cdn-apple.com/appleauth/static/jsapi/appleid/1/hu_HU/appleid.auth.js"
|
||||
strategy="afterInteractive"
|
||||
onReady={loaded}
|
||||
onError={() => setError("Nem sikerült betölteni az Apple-belépést. Ellenőrizd a hálózatot vagy a reklámblokkolót.")}
|
||||
/>
|
||||
<button type="button" className="btn-social btn-apple" onClick={signIn} disabled={!ready || busy}>
|
||||
<span className="btn-social-icon">
|
||||
<AppleMark />
|
||||
</span>
|
||||
{busy ? "Belépés…" : "Folytatás Apple-fiókkal"}
|
||||
</button>
|
||||
{error && (
|
||||
<p className="msg msg-error" role="alert">
|
||||
{error}
|
||||
</p>
|
||||
)}
|
||||
{uninvited !== null && (
|
||||
<>
|
||||
<p className="msg msg-error" role="alert">
|
||||
{inviteToken
|
||||
? "Ez a meghívó már nem érvényes, és ehhez az Apple-fiókhoz sem tartozik másik."
|
||||
: "A Sorsfonalak jelenleg meghívásos, és ehhez az Apple-fiókhoz nem tartozik meghívó. Ha kaptál meghívót, nyisd meg a levélben kapott linket, vagy lépj be azzal a fiókkal, amelynek a címére a meghívó szólt."}
|
||||
</p>
|
||||
<Waitlist email={uninvited.endsWith("@privaterelay.appleid.com") ? "" : uninvited} />
|
||||
</>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -8,14 +8,19 @@ import { BACKEND_URL, getMe } from "@/lib/server";
|
||||
import { formatDate } from "@/lib/astro";
|
||||
import type { InvitationLanding, PublicConfig } from "@/lib/types";
|
||||
|
||||
import { AppleLogin } from "./AppleLogin";
|
||||
import { GoogleLogin } from "./GoogleLogin";
|
||||
|
||||
export const metadata: Metadata = { title: "Belépés" };
|
||||
|
||||
/** Only local paths, so the login cannot redirect to another site. */
|
||||
/**
|
||||
* Only local paths, so the login cannot redirect to another site: one leading
|
||||
* slash, no backslash (browsers read "/\\evil.com" as "//evil.com") and no
|
||||
* control characters.
|
||||
*/
|
||||
function safeTarget(value: string | string[] | undefined): string {
|
||||
const v = Array.isArray(value) ? value[0] : value;
|
||||
return v && v.startsWith("/") && !v.startsWith("//") ? v : "/";
|
||||
return v && /^\/(?![/\\])[^\\\u0000-\u001f]*$/.test(v) ? v : "/";
|
||||
}
|
||||
|
||||
async function loadConfig(): Promise<PublicConfig | null> {
|
||||
@@ -43,7 +48,7 @@ const CLOSED: Record<string, string> = {
|
||||
};
|
||||
|
||||
/** The invitation the visitor came with: who sent it and what they wrote. */
|
||||
function InvitationCard({ invitation }: { invitation: InvitationLanding | null }) {
|
||||
function InvitationCard({ invitation, apple }: { invitation: InvitationLanding | null; apple: boolean }) {
|
||||
if (!invitation) {
|
||||
return (
|
||||
<p className="msg msg-error" role="alert">
|
||||
@@ -66,7 +71,7 @@ function InvitationCard({ invitation }: { invitation: InvitationLanding | null }
|
||||
</p>
|
||||
{invitation.message && <blockquote className="invite-quote">{invitation.message}</blockquote>}
|
||||
<p className="hint" style={{ margin: 0 }}>
|
||||
Bármelyik Google-fiókoddal elfogadhatod. Érvényes: {formatDate(invitation.expires_at).replace(/\.$/, "")}-ig.
|
||||
Bármelyik {apple ? "Google- vagy Apple-fiókoddal" : "Google-fiókoddal"} elfogadhatod. Érvényes: {formatDate(invitation.expires_at).replace(/\.$/, "")}-ig.
|
||||
</p>
|
||||
</div>
|
||||
);
|
||||
@@ -83,6 +88,8 @@ export default async function LoginPage({ searchParams }: { searchParams: Promis
|
||||
inviteToken ? loadInvitation(inviteToken) : Promise.resolve(null),
|
||||
]);
|
||||
const clientId = config?.google_login.enabled ? config.google_login.client_id : null;
|
||||
const appleId = config?.apple_login?.enabled ? config.apple_login.client_id : null;
|
||||
const pendingInvite = invitation?.status === "pending" ? inviteToken : null;
|
||||
const inviteOnly = config?.signup_mode === "invite";
|
||||
|
||||
return (
|
||||
@@ -96,8 +103,8 @@ export default async function LoginPage({ searchParams }: { searchParams: Promis
|
||||
Születési képlet, szinasztria és közösség – egy helyen.
|
||||
</p>
|
||||
<p className="ai-line" style={{ fontSize: 15 }}>
|
||||
Részletes elemzések a legfejlettebb AI-modellekkel: egy tapasztalt asztrológushoz közelítő mélység, töredék
|
||||
áron.
|
||||
Részletes, személyre szóló elemzések a legfejlettebb AI-modellekkel: percek alatt, egy személyes konzultáció
|
||||
árának töredékéért.
|
||||
</p>
|
||||
</div>
|
||||
</aside>
|
||||
@@ -107,17 +114,16 @@ export default async function LoginPage({ searchParams }: { searchParams: Promis
|
||||
<h1 style={{ fontSize: 44 }}>{rawToken ? "Meghívó" : "Belépés"}</h1>
|
||||
<p className="muted">{rawToken ? "Lépj be, és már kezdheted is." : "Üdv újra! Lépj be a fiókodba."}</p>
|
||||
</div>
|
||||
{rawToken && <InvitationCard invitation={inviteToken ? invitation : null} />}
|
||||
{rawToken && <InvitationCard invitation={inviteToken ? invitation : null} apple={appleId !== null} />}
|
||||
{config === null ? (
|
||||
<p className="msg msg-error" role="alert">
|
||||
A szerver most nem érhető el. Próbáld újra egy kicsit később.
|
||||
</p>
|
||||
) : clientId ? (
|
||||
<GoogleLogin
|
||||
clientId={clientId}
|
||||
target={target}
|
||||
inviteToken={invitation?.status === "pending" ? inviteToken : null}
|
||||
/>
|
||||
<div className="field" style={{ gap: 12 }}>
|
||||
<GoogleLogin clientId={clientId} target={target} inviteToken={pendingInvite} />
|
||||
{appleId && <AppleLogin clientId={appleId} target={target} inviteToken={pendingInvite} />}
|
||||
</div>
|
||||
) : (
|
||||
<p className="msg msg-error" role="alert">
|
||||
A Google-belépés még nincs beállítva (a backend <code>GOOGLE_CLIENT_IDS</code> változója üres).
|
||||
|
||||
@@ -64,6 +64,28 @@ p { margin: 0; }
|
||||
.nav a { color: var(--ink-2); text-decoration: none; padding: 10px 12px; border-radius: 8px; min-height: 44px; display: inline-flex; align-items: center; }
|
||||
.nav a:hover, .nav a[aria-current="page"] { color: var(--gold); background: rgba(217, 180, 106, 0.08); }
|
||||
.who { display: flex; align-items: center; gap: 12px; color: var(--muted); font-size: 14px; }
|
||||
.user-menu { position: relative; }
|
||||
.who-name {
|
||||
display: inline-flex; align-items: center; gap: 6px; min-height: 40px; padding: 0 10px; cursor: pointer;
|
||||
border: 1px solid var(--line-2); border-radius: 999px; background: none; color: var(--ink-2); font: inherit; font-size: 14px;
|
||||
}
|
||||
.who-name:hover, .who-name[aria-expanded="true"] { color: var(--gold); border-color: #5a6790; }
|
||||
.who-chevron { width: 14px; height: 14px; flex: none; fill: none; stroke: currentColor; stroke-width: 2; stroke-linecap: round; stroke-linejoin: round; }
|
||||
.who-name[aria-expanded="true"] .who-chevron { transform: rotate(180deg); }
|
||||
.user-menu-list {
|
||||
position: absolute; right: 0; top: calc(100% + 8px); z-index: 30; min-width: 200px; padding: 6px;
|
||||
display: flex; flex-direction: column; background: var(--panel); border: 1px solid var(--line-2); border-radius: 12px;
|
||||
box-shadow: 0 16px 40px rgba(0, 0, 0, 0.45);
|
||||
}
|
||||
.user-menu-item {
|
||||
display: flex; align-items: center; min-height: 40px; padding: 0 12px; border: 0; border-radius: 8px; background: none;
|
||||
color: var(--ink); font: inherit; font-size: 14px; text-align: left; text-decoration: none; cursor: pointer;
|
||||
}
|
||||
.user-menu-item:hover, .user-menu-item:focus-visible { background: rgba(255, 255, 255, 0.05); color: var(--gold); }
|
||||
.user-menu-item[aria-current="page"] { color: var(--gold); }
|
||||
.user-menu-logout { border-top: 1px solid var(--line); border-radius: 0 0 8px 8px; margin-top: 4px; padding-top: 2px; color: var(--muted); }
|
||||
.who-name-text { max-width: 220px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
|
||||
.who-icon { width: 18px; height: 18px; flex: none; fill: none; stroke: currentColor; stroke-width: 1.6; stroke-linecap: round; }
|
||||
.pkg-pill {
|
||||
display: inline-flex; align-items: center; gap: 6px; min-height: 32px; padding: 0 12px; border-radius: 999px;
|
||||
border: 1px solid rgba(217, 180, 106, 0.5); color: var(--gold); text-decoration: none; font-size: 13px; white-space: nowrap;
|
||||
@@ -188,6 +210,11 @@ td.num { font-variant-numeric: tabular-nums; white-space: nowrap; }
|
||||
.social-login:hover .btn-social { border-color: #5a6790; background: rgba(255, 255, 255, 0.03); }
|
||||
.social-login:focus-within .btn-social { outline: 2px solid var(--gold); outline-offset: 2px; }
|
||||
.social-login[data-ready="false"] .btn-social { opacity: 0.6; }
|
||||
/* Sign in with Apple: Apple's white button style. */
|
||||
.btn-apple { background: #fff; border-color: #fff; color: #000; cursor: pointer; }
|
||||
.btn-apple:hover:not(:disabled) { background: #e8e8ed; border-color: #e8e8ed; }
|
||||
.btn-apple:focus-visible { outline: 2px solid var(--gold); outline-offset: 2px; }
|
||||
.btn-apple:disabled { opacity: 0.6; cursor: default; }
|
||||
.gsi-overlay {
|
||||
position: absolute; inset: 0; display: flex; align-items: center; justify-content: center;
|
||||
opacity: 0.001; overflow: hidden; cursor: pointer;
|
||||
@@ -334,7 +361,8 @@ td.num { font-variant-numeric: tabular-nums; white-space: nowrap; }
|
||||
h1 { font-size: 32px; }
|
||||
.site-header { padding: 10px 16px; gap: 12px; }
|
||||
.nav { order: 3; flex-basis: 100%; }
|
||||
.who-name { display: none; }
|
||||
.who-name-text { max-width: 120px; }
|
||||
.who { margin-left: auto; }
|
||||
.card { padding: 18px; }
|
||||
.auth-aside { padding: 28px 20px; min-height: 0; }
|
||||
.wheel { width: 60%; }
|
||||
@@ -741,8 +769,6 @@ a.pair-row:hover strong { color: var(--gold); }
|
||||
.share-cta .btn { align-self: flex-start; }
|
||||
|
||||
/* Promo codes: redeeming (header, packages page, /bevaltas) and the admin page */
|
||||
.redeem-link { color: var(--ink-2); font-size: 13px; text-decoration: none; white-space: nowrap; }
|
||||
.redeem-link:hover { color: var(--gold); text-decoration: underline; text-underline-offset: 3px; }
|
||||
.redeem { display: flex; flex-direction: column; gap: 8px; }
|
||||
.redeem-row { display: flex; gap: 8px; flex-wrap: wrap; }
|
||||
.redeem-input { flex: 1 1 220px; width: auto; font-family: ui-monospace, SFMono-Regular, Menlo, monospace; letter-spacing: 1.5px; text-transform: uppercase; }
|
||||
@@ -938,6 +964,28 @@ a.pair-row:hover strong { color: var(--gold); }
|
||||
.lp-why-card { gap: 12px; padding: 28px; }
|
||||
.lp-why-icon { width: 36px; height: 36px; fill: none; stroke: var(--gold); stroke-width: 1.4; stroke-linecap: round; stroke-linejoin: round; }
|
||||
|
||||
/* Home page: tarot, a quiet line under the yearly forecast and the comparison */
|
||||
.lp-tarot { flex-direction: row; align-items: center; gap: 32px; padding: 22px 32px; margin-top: -16px; }
|
||||
.lp-tarot-cards { position: relative; width: 132px; height: 112px; flex: none; }
|
||||
.lp-tarot-cards .tarot-card { position: absolute; top: 12px; width: 56px; border-radius: 5px; box-shadow: 0 6px 16px rgba(0, 0, 0, 0.4); }
|
||||
.lp-tarot-cards .tarot-card:nth-child(1) { left: 4px; transform: rotate(-11deg); }
|
||||
.lp-tarot-cards .tarot-card:nth-child(2) { left: 38px; top: 4px; }
|
||||
.lp-tarot-cards .tarot-card:nth-child(3) { left: 72px; transform: rotate(11deg); }
|
||||
.lp-tarot-text { display: flex; flex-direction: column; gap: 6px; flex: 1 1 auto; min-width: 0; }
|
||||
.lp-tarot-text .lp-small { max-width: 640px; }
|
||||
.lp-tarot-title { font-size: 24px; line-height: 1.15; }
|
||||
.lp-tarot-link { flex: none; font-size: 14px; font-weight: 500; white-space: nowrap; }
|
||||
@media (max-width: 720px) {
|
||||
.lp-tarot { flex-wrap: wrap; gap: 14px 16px; padding: 22px; }
|
||||
.lp-tarot-cards { width: 104px; height: 88px; }
|
||||
.lp-tarot-cards .tarot-card { width: 44px; top: 10px; }
|
||||
.lp-tarot-cards .tarot-card:nth-child(1) { left: 2px; }
|
||||
.lp-tarot-cards .tarot-card:nth-child(2) { left: 30px; top: 3px; }
|
||||
.lp-tarot-cards .tarot-card:nth-child(3) { left: 58px; }
|
||||
.lp-tarot-text { flex: 1 1 100%; }
|
||||
.lp-tarot-link { flex-basis: 100%; min-height: 44px; display: inline-flex; align-items: center; }
|
||||
}
|
||||
|
||||
/* Home page footer: payment and invoicing partners */
|
||||
.lp-partners { display: flex; flex-wrap: wrap; align-items: center; justify-content: center; gap: 10px 16px; padding-bottom: 20px; margin-bottom: 20px; border-bottom: 1px solid var(--line); }
|
||||
.lp-partner { height: 26px; width: auto; opacity: 0.65; transition: opacity 0.2s; }
|
||||
@@ -981,6 +1029,15 @@ a.pair-row:hover strong { color: var(--gold); }
|
||||
.tarot-spread:hover { border-color: #5a6790; }
|
||||
.tarot-spread.is-active { border-color: var(--gold); box-shadow: 0 0 0 1px var(--gold) inset; }
|
||||
.tarot-spread:has(input:focus-visible) { outline: 2px solid var(--gold); outline-offset: 2px; }
|
||||
.tarot-topics { border: 0; margin: 0; padding: 0; display: flex; flex-wrap: wrap; gap: 8px; }
|
||||
.tarot-topics legend { margin-bottom: 8px; }
|
||||
.tarot-topic {
|
||||
display: inline-flex; align-items: center; min-height: 38px; padding: 0 16px; cursor: pointer; font-size: 14px;
|
||||
border: 1px solid var(--line-2); border-radius: 999px; background: var(--panel-2); color: var(--ink-2);
|
||||
}
|
||||
.tarot-topic:hover { border-color: #5a6790; }
|
||||
.tarot-topic.is-active { border-color: var(--gold); color: var(--gold); background: rgba(217, 180, 106, 0.08); }
|
||||
.tarot-topic:has(input:focus-visible) { outline: 2px solid var(--gold); outline-offset: 2px; }
|
||||
.tarot-spread-name { font-family: var(--font-display); font-size: 20px; font-weight: 600; }
|
||||
|
||||
.tarot-stage { align-items: stretch; }
|
||||
@@ -1007,6 +1064,17 @@ a.pair-row:hover strong { color: var(--gold); }
|
||||
.tarot-fan-card .tarot-card { box-shadow: 0 6px 16px rgba(0, 0, 0, 0.4); }
|
||||
.tarot-fan-card:hover:not(:disabled), .tarot-fan-card:focus-visible { transform: rotate(calc(var(--i) * var(--step))) translateY(-14px); }
|
||||
.tarot-fan-card.is-picked { opacity: 0; transform: rotate(calc(var(--i) * var(--step))) translateY(-60px); cursor: default; }
|
||||
.tarot-fan-card { animation: tarot-deal 0.7s cubic-bezier(0.3, 0.7, 0.3, 1) backwards; }
|
||||
@keyframes tarot-deal { from { transform: rotate(0deg); } }
|
||||
span.tarot-fan-card { cursor: default; }
|
||||
.tarot-fan-card.is-lifted { transform: rotate(calc(var(--i) * var(--step))) translateY(-26px); }
|
||||
.tarot-fan-card.is-lifted .tarot-card { box-shadow: 0 0 0 1px var(--gold), 0 10px 26px rgba(217, 180, 106, 0.35); }
|
||||
|
||||
/* The example page: a reading played from the deck to the text. */
|
||||
.tarot-demo { display: flex; flex-direction: column; gap: 18px; padding-top: 8px; }
|
||||
.tarot-demo-status { text-align: center; min-height: 36px; display: flex; align-items: center; justify-content: center; }
|
||||
.tarot-demo-text { max-height: 0; overflow: hidden; opacity: 0; transform: translateY(16px); }
|
||||
.tarot-demo-text.is-shown { max-height: none; overflow: visible; opacity: 1; transform: none; transition: opacity 0.8s ease, transform 0.8s ease; }
|
||||
|
||||
.tarot-result { display: flex; flex-direction: column; gap: 28px; }
|
||||
.tarot-result-head { display: flex; flex-direction: column; gap: 10px; }
|
||||
@@ -1034,5 +1102,15 @@ a.pair-row:hover strong { color: var(--gold); }
|
||||
.tarot-history-cards .tarot-card-xs:nth-child(n + 4) { display: none; }
|
||||
}
|
||||
@media (prefers-reduced-motion: reduce) {
|
||||
.tarot-flip-inner, .tarot-fan-card { transition: none; animation: none; }
|
||||
.tarot-flip-inner, .tarot-fan-card, .tarot-demo-text { transition: none; animation: none; }
|
||||
}
|
||||
|
||||
/* Birth date and time: our own Hungarian fields (not the browser's date and time inputs) */
|
||||
.birth-fields { border: 0; margin: 0; padding: 0; min-width: 0; }
|
||||
.birth-fields legend { padding: 0; margin-bottom: 8px; }
|
||||
.birth-row { display: flex; align-items: center; gap: 8px; }
|
||||
.birth-year { width: 5.5em; flex: none; }
|
||||
.birth-month { flex: 1 1 auto; min-width: 0; }
|
||||
.birth-day { width: 5.2em; flex: none; }
|
||||
.birth-time { width: 4.4em; flex: none; text-align: center; }
|
||||
.birth-colon { color: var(--muted); font-weight: 600; }
|
||||
|
||||
@@ -24,6 +24,7 @@ export default async function TarotReadingPage({ params }: { params: Promise<{ i
|
||||
← Kártyajóslás
|
||||
</Link>
|
||||
<span className="eyebrow">
|
||||
{reading.topic_name ? `${reading.topic_name} · ` : ""}
|
||||
{reading.spread_name} · {day(reading.created_at)}
|
||||
</span>
|
||||
</div>
|
||||
|
||||
@@ -2,14 +2,14 @@ import type { Metadata } from "next";
|
||||
import Link from "next/link";
|
||||
|
||||
import { PublicHeader } from "@/components/SiteHeader";
|
||||
import { TarotResult } from "@/components/tarot/TarotResult";
|
||||
import example from "@/content/tarot-pelda.json";
|
||||
import { TarotDemo, type TarotExample } from "@/components/tarot/TarotDemo";
|
||||
import data from "@/content/tarot-pelda.json";
|
||||
import { getMe } from "@/lib/server";
|
||||
import type { TarotContent, TarotReading } from "@/lib/tarot";
|
||||
|
||||
export const metadata: Metadata = {
|
||||
title: "Példajóslás",
|
||||
description: "Így néz ki egy Sorsfonalak-kártyajóslás: három lap egy kitalált kérdésre, személyre szabott értelmezéssel.",
|
||||
description:
|
||||
"Így néz ki egy Sorsfonalak-kártyajóslás: lapválasztás a pakliból, kirakás és személyre szabott értelmezés, munkáról és párkapcsolatról.",
|
||||
};
|
||||
|
||||
/** A full example tarot reading for a made-up question, for visitors and users without readings. */
|
||||
@@ -23,17 +23,11 @@ export default async function TarotExamplePage() {
|
||||
<span className="eyebrow">Példajóslás</span>
|
||||
<h1>Így néz ki egy kártyajóslás</h1>
|
||||
<p className="muted">
|
||||
A kérdés és a képlet kitalált ({example.signs}), a kirakás: {example.spread_name}. A saját jóslásod a te
|
||||
kérdésedre, a te lapjaidra és a képletedre készül.
|
||||
Két kitalált kérdés, két kirakás: nézd meg, hogyan választ a pakliból, hogyan fordulnak fel a lapok, és mit
|
||||
mondanak együtt. A saját jóslásod a te kérdésedre, a te lapjaidra és a képletedre készül.
|
||||
</p>
|
||||
</div>
|
||||
<section className="card">
|
||||
<TarotResult
|
||||
cards={example.cards as TarotReading["cards"]}
|
||||
question={example.question}
|
||||
content={example.content as TarotContent}
|
||||
/>
|
||||
</section>
|
||||
<TarotDemo examples={data.examples as TarotExample[]} />
|
||||
<section className="card" style={{ gap: 12 }}>
|
||||
<p>
|
||||
{me
|
||||
|
||||
@@ -24,7 +24,7 @@ export async function generateMetadata(): Promise<Metadata> {
|
||||
return {
|
||||
title: { absolute: "Sorsfonalak – születési képlet, éves előrejelzés, kapcsolati összevetés" },
|
||||
description:
|
||||
"Percre pontos születési képlet és személyre szóló elemzés a legfejlettebb AI-modellekkel: egy tapasztalt asztrológushoz közelítő mélység, töredék áron. Éves előrejelzés és kapcsolati összevetés.",
|
||||
"Percre pontos születési képlet és személyre szóló elemzés a legfejlettebb AI-modellekkel, percek alatt és töredék áron. Éves előrejelzés, kapcsolati összevetés és kártyajóslás.",
|
||||
alternates: { canonical: `${base}/` },
|
||||
openGraph: { type: "website", siteName: "Sorsfonalak", locale: "hu_HU", url: `${base}/`, title, description, images: [image] },
|
||||
twitter: { card: "summary_large_image", title, description, images: [image.url] },
|
||||
|
||||
@@ -12,7 +12,7 @@ export const metadata: Metadata = {
|
||||
|
||||
const DATA: [string, string, string][] = [
|
||||
[
|
||||
"Your Google account's name, e-mail address and ID (passed on by Google when you sign in)",
|
||||
"Your Google or Apple account's name, e-mail address and ID (passed on by Google or Apple when you sign in)",
|
||||
"Creating your account, signing you in, contacting you",
|
||||
"Performance of a contract (GDPR Art. 6(1)(b))",
|
||||
],
|
||||
@@ -168,6 +168,13 @@ export default async function PrivacyPolicyPage() {
|
||||
</a>
|
||||
, including the Limited Use requirements.
|
||||
</p>
|
||||
<p>
|
||||
<strong>Signing in with Apple:</strong> if you choose “Sign in with Apple”, Apple passes us your account's
|
||||
unique ID and your e-mail address, and your name the first time. If you hide your address, we get an Apple
|
||||
relay address (<code>…@privaterelay.appleid.com</code>) and Apple forwards our e-mails to you. We use these
|
||||
for the same purposes and in the same way as the Google data. You can revoke access in your Apple ID settings
|
||||
(Sign-In and Security › Sign in with Apple).
|
||||
</p>
|
||||
</section>
|
||||
|
||||
<section>
|
||||
|
||||
@@ -16,6 +16,41 @@ const ERRORS: Record<string, string> = {
|
||||
invalid_date: "Érvénytelen dátum.",
|
||||
};
|
||||
|
||||
const MONTHS = [
|
||||
"január",
|
||||
"február",
|
||||
"március",
|
||||
"április",
|
||||
"május",
|
||||
"június",
|
||||
"július",
|
||||
"augusztus",
|
||||
"szeptember",
|
||||
"október",
|
||||
"november",
|
||||
"december",
|
||||
];
|
||||
|
||||
const pad = (n: number) => String(n).padStart(2, "0");
|
||||
const daysIn = (year: number, month: number) => new Date(Date.UTC(year || 2000, month, 0)).getUTCDate();
|
||||
|
||||
/** "YYYY-MM-DD" from the three fields, or null while it is not a real date. */
|
||||
function composeDate(year: string, month: string, day: string): string | null {
|
||||
const y = Number(year);
|
||||
const m = Number(month);
|
||||
const d = Number(day);
|
||||
if (!/^\d{4}$/.test(year) || y < 1000 || !m || !d || d > daysIn(y, m)) return null;
|
||||
return `${year}-${pad(m)}-${pad(d)}`;
|
||||
}
|
||||
|
||||
/** "HH:MM" from the two fields, or null while it is not a real time. */
|
||||
function composeTime(hour: string, minute: string): string | null {
|
||||
if (!/^\d{1,2}$/.test(hour) || !/^\d{1,2}$/.test(minute)) return null;
|
||||
const h = Number(hour);
|
||||
const m = Number(minute);
|
||||
return h <= 23 && m <= 59 ? `${pad(h)}:${pad(m)}` : null;
|
||||
}
|
||||
|
||||
/** Someone else's chart: added with a name, or (with `chartId`) corrected. */
|
||||
export type PersonTarget = { chartId?: string; name?: string };
|
||||
|
||||
@@ -32,8 +67,16 @@ export function BirthForm({
|
||||
onSaved: (chartId: string) => void;
|
||||
}) {
|
||||
const [name, setName] = useState(person?.name ?? "");
|
||||
const [date, setDate] = useState(initial?.date ?? "");
|
||||
const [time, setTime] = useState(initial?.time?.slice(0, 5) ?? "");
|
||||
// Our own fields, not the browser's date and time inputs: those follow the
|
||||
// operating system's or the browser's region (US order, AM/PM in Safari).
|
||||
const [year, setYear] = useState(initial?.date?.slice(0, 4) ?? "");
|
||||
const [month, setMonth] = useState(initial?.date ? String(Number(initial.date.slice(5, 7))) : "");
|
||||
const [day, setDay] = useState(initial?.date ? String(Number(initial.date.slice(8, 10))) : "");
|
||||
const [hour, setHour] = useState(initial?.time?.slice(0, 2) ?? "");
|
||||
const [minute, setMinute] = useState(initial?.time?.slice(3, 5) ?? "");
|
||||
const minuteRef = useRef<HTMLInputElement>(null);
|
||||
const date = composeDate(year, month, day) ?? "";
|
||||
const time = composeTime(hour, minute) ?? "";
|
||||
const [timeUnknown, setTimeUnknown] = useState(initial ? !initial.time : false);
|
||||
const [country, setCountry] = useState(initial?.country ?? "HU");
|
||||
const [place, setPlace] = useState<Place | null>(
|
||||
@@ -57,8 +100,11 @@ export function BirthForm({
|
||||
e.preventDefault();
|
||||
setError(null);
|
||||
if (person && !name.trim()) return setError("Add meg a nevét.");
|
||||
if (!date) return setError("Add meg a születési dátumot.");
|
||||
if (!timeUnknown && !time) return setError("Add meg a születési időt, vagy jelöld, hogy nem tudod.");
|
||||
if (!year && !month && !day) return setError("Add meg a születési dátumot.");
|
||||
if (!date) return setError("Ellenőrizd a dátumot: az év négy számjegy, és a nap legyen az adott hónapban.");
|
||||
if (date > today) return setError("A születési dátum nem lehet a jövőben.");
|
||||
if (!timeUnknown && !hour && !minute) return setError("Add meg a születési időt, vagy jelöld, hogy nem tudod.");
|
||||
if (!timeUnknown && !time) return setError("Ellenőrizd az időt: óra 0–23, perc 0–59.");
|
||||
if (!place) return setError("Válaszd ki a születési helyet a listából.");
|
||||
setBusy(true);
|
||||
try {
|
||||
@@ -120,37 +166,106 @@ export function BirthForm({
|
||||
</div>
|
||||
)}
|
||||
<div className="grid-2">
|
||||
<div className="field">
|
||||
<label htmlFor="birth-date">Születési dátum</label>
|
||||
<input
|
||||
id="birth-date"
|
||||
type="date"
|
||||
className="inp"
|
||||
min="1000-01-01"
|
||||
max={today}
|
||||
value={date}
|
||||
onChange={(e) => setDate(e.target.value)}
|
||||
required
|
||||
/>
|
||||
</div>
|
||||
<div className="field">
|
||||
<label htmlFor="birth-time">Születési idő (helyi idő)</label>
|
||||
<input
|
||||
id="birth-time"
|
||||
type="time"
|
||||
className="inp"
|
||||
value={timeUnknown ? "" : time}
|
||||
disabled={timeUnknown}
|
||||
onChange={(e) => {
|
||||
setTime(e.target.value);
|
||||
setAmbiguous(false);
|
||||
}}
|
||||
/>
|
||||
<fieldset className="field birth-fields">
|
||||
<legend className="label">Születési dátum</legend>
|
||||
<div className="birth-row">
|
||||
<label className="sr-only" htmlFor="birth-year">
|
||||
Év
|
||||
</label>
|
||||
<input
|
||||
id="birth-year"
|
||||
className="inp birth-year"
|
||||
inputMode="numeric"
|
||||
autoComplete="bday-year"
|
||||
placeholder="év"
|
||||
maxLength={4}
|
||||
value={year}
|
||||
onChange={(e) => setYear(e.target.value.replace(/\D/g, ""))}
|
||||
/>
|
||||
<label className="sr-only" htmlFor="birth-month">
|
||||
Hónap
|
||||
</label>
|
||||
<select
|
||||
id="birth-month"
|
||||
className="inp birth-month"
|
||||
autoComplete="bday-month"
|
||||
value={month}
|
||||
onChange={(e) => setMonth(e.target.value)}
|
||||
>
|
||||
<option value="">hónap</option>
|
||||
{MONTHS.map((m, i) => (
|
||||
<option key={m} value={i + 1}>
|
||||
{m}
|
||||
</option>
|
||||
))}
|
||||
</select>
|
||||
<label className="sr-only" htmlFor="birth-day">
|
||||
Nap
|
||||
</label>
|
||||
<select
|
||||
id="birth-day"
|
||||
className="inp birth-day"
|
||||
autoComplete="bday-day"
|
||||
value={day}
|
||||
onChange={(e) => setDay(e.target.value)}
|
||||
>
|
||||
<option value="">nap</option>
|
||||
{Array.from({ length: month ? daysIn(Number(year), Number(month)) : 31 }, (_, i) => (
|
||||
<option key={i + 1} value={i + 1}>
|
||||
{i + 1}.
|
||||
</option>
|
||||
))}
|
||||
</select>
|
||||
</div>
|
||||
</fieldset>
|
||||
<fieldset className="field birth-fields">
|
||||
<legend className="label">Születési idő (helyi idő)</legend>
|
||||
<div className="birth-row">
|
||||
<label className="sr-only" htmlFor="birth-hour">
|
||||
Óra
|
||||
</label>
|
||||
<input
|
||||
id="birth-hour"
|
||||
className="inp birth-time"
|
||||
inputMode="numeric"
|
||||
placeholder="óra"
|
||||
maxLength={2}
|
||||
value={timeUnknown ? "" : hour}
|
||||
disabled={timeUnknown}
|
||||
onChange={(e) => {
|
||||
const v = e.target.value.replace(/\D/g, "");
|
||||
setHour(v);
|
||||
setAmbiguous(false);
|
||||
// Two digits (or one that cannot start a valid hour): on to the minutes.
|
||||
if (v.length === 2 || (v.length === 1 && Number(v) > 2)) minuteRef.current?.focus();
|
||||
}}
|
||||
/>
|
||||
<span className="birth-colon" aria-hidden="true">
|
||||
:
|
||||
</span>
|
||||
<label className="sr-only" htmlFor="birth-minute">
|
||||
Perc
|
||||
</label>
|
||||
<input
|
||||
id="birth-minute"
|
||||
ref={minuteRef}
|
||||
className="inp birth-time"
|
||||
inputMode="numeric"
|
||||
placeholder="perc"
|
||||
maxLength={2}
|
||||
value={timeUnknown ? "" : minute}
|
||||
disabled={timeUnknown}
|
||||
onChange={(e) => {
|
||||
setMinute(e.target.value.replace(/\D/g, ""));
|
||||
setAmbiguous(false);
|
||||
}}
|
||||
/>
|
||||
</div>
|
||||
<label className="check">
|
||||
<input type="checkbox" checked={timeUnknown} onChange={(e) => setTimeUnknown(e.target.checked)} />
|
||||
Nem tudom a születési időt
|
||||
</label>
|
||||
</div>
|
||||
</fieldset>
|
||||
</div>
|
||||
|
||||
<div className="grid-2">
|
||||
|
||||
@@ -1,16 +1,17 @@
|
||||
/** Shown where people decide: the analyses are written by top AI models (never named: a business secret). */
|
||||
export const AI_SHORT =
|
||||
"A legfejlettebb AI-modellek írják: egy tapasztalt asztrológus írásos elemzéséhez közelítő mélység, töredék áron.";
|
||||
"A legfejlettebb AI-modellek írják a képleted pontos adataiból: alapos, személyre szabott elemzés percek alatt, egy személyes konzultáció árának töredékéért.";
|
||||
|
||||
/** A highlighted note on the analysis quality. */
|
||||
export function AiNote() {
|
||||
return (
|
||||
<section className="card ai-note" aria-labelledby="ai-note-title">
|
||||
<span className="eyebrow">Az elemzésekről</span>
|
||||
<h2 id="ai-note-title">Profi mélység, töredék áron</h2>
|
||||
<h2 id="ai-note-title">Alapos elemzés, töredék áron</h2>
|
||||
<p className="muted">
|
||||
Az elemzéseket a legfejlettebb AI-modellek írják, a képleted pontos pozícióiból. Részletességben és
|
||||
árnyaltságban megközelítik egy tapasztalt asztrológus írásos elemzését, annak az árnak a töredékéért.
|
||||
Az elemzéseket a legfejlettebb AI-modellek írják, a képleted csillagászati pontosságú adataiból. Részletes,
|
||||
személyre szabott szöveget kapsz percek alatt, egy személyes konzultáció árának töredékéért, és amit nem értesz,
|
||||
arra rá is kérdezhetsz.
|
||||
</p>
|
||||
</section>
|
||||
);
|
||||
|
||||
@@ -5,7 +5,7 @@ import { useState } from "react";
|
||||
|
||||
import { api } from "@/lib/api";
|
||||
|
||||
export function LogoutButton() {
|
||||
export function LogoutButton({ className = "btn btn-sm", role }: { className?: string; role?: "menuitem" }) {
|
||||
const router = useRouter();
|
||||
const [busy, setBusy] = useState(false);
|
||||
async function logout() {
|
||||
@@ -20,7 +20,7 @@ export function LogoutButton() {
|
||||
router.refresh();
|
||||
}
|
||||
return (
|
||||
<button type="button" className="btn btn-sm" onClick={logout} disabled={busy}>
|
||||
<button type="button" className={className} role={role} onClick={logout} disabled={busy}>
|
||||
Kilépés
|
||||
</button>
|
||||
);
|
||||
|
||||
@@ -2,8 +2,8 @@ import Link from "next/link";
|
||||
|
||||
import type { Me } from "@/lib/types";
|
||||
|
||||
import { LogoutButton } from "./LogoutButton";
|
||||
import { NavLinks } from "./NavLinks";
|
||||
import { UserMenu } from "./UserMenu";
|
||||
|
||||
/** The mark: the orbit, the thread (an S, with the crossbar an f) and a star on the rim. */
|
||||
export function LogoMark({ className = "logo-mark" }: { className?: string }) {
|
||||
@@ -91,8 +91,6 @@ export function SiteHeader({ me }: { me: Me }) {
|
||||
{ href: "/osszevetesek", label: "Összevetések" },
|
||||
{ href: "/kartyajoslas", label: "Kártyajóslás" },
|
||||
{ href: "/csomagok", label: "Csomagok" },
|
||||
...(me.invoice_count > 0 ? [{ href: "/szamlak", label: "Számláim" }] : []),
|
||||
{ href: "/profil", label: "Profil" },
|
||||
];
|
||||
if (me.user.roles.includes("admin")) links.push({ href: "/admin", label: "Admin" });
|
||||
return (
|
||||
@@ -101,11 +99,7 @@ export function SiteHeader({ me }: { me: Me }) {
|
||||
<NavLinks links={links} />
|
||||
<div className="who">
|
||||
<PackageBadge me={me} />
|
||||
<Link href="/bevaltas" className="redeem-link">
|
||||
Kód beváltása
|
||||
</Link>
|
||||
<span className="who-name">{me.user.display_name || me.user.email}</span>
|
||||
<LogoutButton />
|
||||
<UserMenu name={me.user.display_name || me.user.email} invoices={me.invoice_count > 0} />
|
||||
</div>
|
||||
</header>
|
||||
);
|
||||
|
||||
@@ -0,0 +1,82 @@
|
||||
"use client";
|
||||
|
||||
import Link from "next/link";
|
||||
import { usePathname } from "next/navigation";
|
||||
import { useEffect, useId, useRef, useState } from "react";
|
||||
|
||||
import { LogoutButton } from "./LogoutButton";
|
||||
|
||||
/**
|
||||
* The account menu under the user's name (top right): profile, invoices,
|
||||
* redeeming a code, logging out. Closes on a click outside, Escape, or
|
||||
* moving to another page.
|
||||
*/
|
||||
export function UserMenu({ name, invoices }: { name: string; invoices: boolean }) {
|
||||
const [open, setOpen] = useState(false);
|
||||
const box = useRef<HTMLDivElement>(null);
|
||||
const button = useRef<HTMLButtonElement>(null);
|
||||
const menuId = useId();
|
||||
const pathname = usePathname();
|
||||
|
||||
useEffect(() => setOpen(false), [pathname]);
|
||||
useEffect(() => {
|
||||
if (!open) return;
|
||||
const outside = (e: PointerEvent) => {
|
||||
if (box.current && !box.current.contains(e.target as Node)) setOpen(false);
|
||||
};
|
||||
document.addEventListener("pointerdown", outside);
|
||||
return () => document.removeEventListener("pointerdown", outside);
|
||||
}, [open]);
|
||||
|
||||
function keydown(e: React.KeyboardEvent) {
|
||||
if (e.key === "Escape" && open) {
|
||||
setOpen(false);
|
||||
button.current?.focus();
|
||||
}
|
||||
}
|
||||
|
||||
const items = [
|
||||
{ href: "/profil", label: "Profil" },
|
||||
...(invoices ? [{ href: "/szamlak", label: "Számláim" }] : []),
|
||||
{ href: "/bevaltas", label: "Kód beváltása" },
|
||||
];
|
||||
|
||||
return (
|
||||
<div className="user-menu" ref={box} onKeyDown={keydown}>
|
||||
<button
|
||||
ref={button}
|
||||
type="button"
|
||||
className="who-name"
|
||||
aria-expanded={open}
|
||||
aria-controls={menuId}
|
||||
aria-haspopup="menu"
|
||||
onClick={() => setOpen((o) => !o)}
|
||||
>
|
||||
<svg viewBox="0 0 24 24" aria-hidden="true" className="who-icon">
|
||||
<circle cx="12" cy="8" r="4" />
|
||||
<path d="M4 20c1.5-4 4.5-6 8-6s6.5 2 8 6" />
|
||||
</svg>
|
||||
<span className="who-name-text">{name}</span>
|
||||
<svg viewBox="0 0 24 24" aria-hidden="true" className="who-chevron">
|
||||
<path d="M6 9l6 6 6-6" />
|
||||
</svg>
|
||||
</button>
|
||||
{open && (
|
||||
<div id={menuId} className="user-menu-list" role="menu" aria-label="Fiók">
|
||||
{items.map((item) => (
|
||||
<Link
|
||||
key={item.href}
|
||||
href={item.href}
|
||||
role="menuitem"
|
||||
className="user-menu-item"
|
||||
aria-current={pathname.startsWith(item.href) ? "page" : undefined}
|
||||
>
|
||||
{item.label}
|
||||
</Link>
|
||||
))}
|
||||
<LogoutButton className="user-menu-item user-menu-logout" role="menuitem" />
|
||||
</div>
|
||||
)}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,102 @@
|
||||
"use client";
|
||||
|
||||
import { useEffect, useState } from "react";
|
||||
|
||||
import type { TarotContent, TarotReading } from "@/lib/tarot";
|
||||
|
||||
import { TarotResult } from "./TarotResult";
|
||||
import { TarotFan, TarotSlots } from "./TarotSpread";
|
||||
|
||||
export interface TarotExample {
|
||||
id: string;
|
||||
label: string;
|
||||
signs: string;
|
||||
spread_name: string;
|
||||
question: string;
|
||||
cards: TarotReading["cards"];
|
||||
content: TarotContent;
|
||||
}
|
||||
|
||||
/** The fan cards the demo "picks", in order. */
|
||||
const PICKS = [4, 13, 8, 17, 2];
|
||||
|
||||
/**
|
||||
* Plays a reading: the cards are picked from the fanned deck one by one,
|
||||
* laid out, turned over, then the written reading appears below. The text is
|
||||
* on the page from the start (hidden while the animation plays).
|
||||
*/
|
||||
function Demo({ example }: { example: TarotExample }) {
|
||||
const n = example.cards.length;
|
||||
const done = 3 * n + 2;
|
||||
const [step, setStep] = useState(0);
|
||||
|
||||
// Without motion the end state shows at once.
|
||||
useEffect(() => {
|
||||
if (window.matchMedia("(prefers-reduced-motion: reduce)").matches) setStep(done);
|
||||
}, [done]);
|
||||
|
||||
useEffect(() => {
|
||||
if (step >= done) return;
|
||||
const picking = step <= 2 * n;
|
||||
const delay = step === 0 ? 900 : picking ? (step % 2 === 1 ? 420 : 520) : 680;
|
||||
const t = setTimeout(() => setStep((s) => s + 1), delay);
|
||||
return () => clearTimeout(t);
|
||||
}, [step, done, n]);
|
||||
|
||||
const pickedCount = Math.min(n, Math.floor(step / 2));
|
||||
const lifted = step % 2 === 1 && step < 2 * n ? PICKS[(step - 1) / 2] : null;
|
||||
const revealed = Math.max(0, Math.min(n, step - (2 * n + 1)));
|
||||
const finished = step >= done;
|
||||
|
||||
return (
|
||||
<div className="tarot-demo">
|
||||
<div className="tarot-stage-head">
|
||||
<span className="eyebrow">{example.spread_name}</span>
|
||||
<p className="tarot-question">„{example.question}”</p>
|
||||
<p className="hint">A kérdés és a képlet kitalált ({example.signs}).</p>
|
||||
</div>
|
||||
<TarotSlots count={n} filled={pickedCount} cards={example.cards} revealed={revealed} />
|
||||
{!finished && <TarotFan picked={PICKS.slice(0, pickedCount)} lifted={lifted} />}
|
||||
<p className="hint tarot-demo-status" aria-live="polite">
|
||||
{finished ? (
|
||||
<button type="button" className="btn btn-sm btn-ghost" onClick={() => setStep(0)}>
|
||||
↻ Húzás újra
|
||||
</button>
|
||||
) : pickedCount < n ? (
|
||||
`Lapválasztás a pakliból: ${pickedCount}/${n}`
|
||||
) : (
|
||||
"A lapok felfordulnak…"
|
||||
)}
|
||||
</p>
|
||||
<div className={finished ? "tarot-demo-text is-shown" : "tarot-demo-text"}>
|
||||
<TarotResult cards={example.cards} question={null} content={example.content} />
|
||||
</div>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
/** The example readings, one tab each. */
|
||||
export function TarotDemo({ examples }: { examples: TarotExample[] }) {
|
||||
const [active, setActive] = useState(examples[0]?.id);
|
||||
const example = examples.find((e) => e.id === active) ?? examples[0];
|
||||
if (!example) return null;
|
||||
return (
|
||||
<section className="card" aria-label="Példajóslások">
|
||||
<div className="tab-list" role="tablist" aria-label="Példák">
|
||||
{examples.map((e) => (
|
||||
<button
|
||||
key={e.id}
|
||||
type="button"
|
||||
role="tab"
|
||||
className="tab"
|
||||
aria-selected={e.id === example.id}
|
||||
onClick={() => setActive(e.id)}
|
||||
>
|
||||
{e.label}
|
||||
</button>
|
||||
))}
|
||||
</div>
|
||||
<Demo key={example.id} example={example} />
|
||||
</section>
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,106 @@
|
||||
"use client";
|
||||
|
||||
import { tarotCard, type TarotReading } from "@/lib/tarot";
|
||||
|
||||
import { TarotCard, TarotCardBack } from "./TarotCard";
|
||||
|
||||
/** Face-down cards in the fan to pick from. */
|
||||
export const FAN = 21;
|
||||
|
||||
/**
|
||||
* The shuffled deck fanned out. With `onPick` the cards are buttons; without
|
||||
* it (the demo) they are only a picture, and `lifted` is the card about to go.
|
||||
*/
|
||||
export function TarotFan({
|
||||
picked,
|
||||
lifted,
|
||||
onPick,
|
||||
}: {
|
||||
picked: number[];
|
||||
lifted?: number | null;
|
||||
onPick?: (i: number) => void;
|
||||
}) {
|
||||
return (
|
||||
<div
|
||||
className="tarot-fan"
|
||||
role={onPick ? "group" : undefined}
|
||||
aria-label={onPick ? "A megkevert pakli" : undefined}
|
||||
aria-hidden={onPick ? undefined : true}
|
||||
>
|
||||
{Array.from({ length: FAN }).map((_, i) => {
|
||||
const className = [
|
||||
"tarot-fan-card",
|
||||
picked.includes(i) ? "is-picked" : "",
|
||||
lifted === i ? "is-lifted" : "",
|
||||
]
|
||||
.filter(Boolean)
|
||||
.join(" ");
|
||||
const style = { "--i": i - (FAN - 1) / 2 } as React.CSSProperties;
|
||||
return onPick ? (
|
||||
<button
|
||||
key={i}
|
||||
type="button"
|
||||
className={className}
|
||||
style={style}
|
||||
onClick={() => onPick(i)}
|
||||
disabled={picked.includes(i)}
|
||||
aria-label={`${i + 1}. lap kiválasztása`}
|
||||
>
|
||||
<TarotCardBack />
|
||||
</button>
|
||||
) : (
|
||||
<span key={i} className={className} style={style}>
|
||||
<TarotCardBack />
|
||||
</span>
|
||||
);
|
||||
})}
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* The places of the spread: empty, a face-down card (`filled`), or the drawn
|
||||
* card turning over (the first `revealed` of `cards`).
|
||||
*/
|
||||
export function TarotSlots({
|
||||
count,
|
||||
filled,
|
||||
cards,
|
||||
revealed,
|
||||
}: {
|
||||
count: number;
|
||||
filled: number;
|
||||
cards?: TarotReading["cards"];
|
||||
revealed: number;
|
||||
}) {
|
||||
return (
|
||||
<ol className="tarot-slots" data-count={count}>
|
||||
{Array.from({ length: count }).map((_, i) => {
|
||||
const drawn = cards?.[i];
|
||||
const card = drawn && i < filled ? tarotCard(drawn.card) : undefined;
|
||||
const flipped = !!card && i < revealed;
|
||||
return (
|
||||
<li key={i} className="tarot-slot">
|
||||
<div className={flipped ? "tarot-flip is-flipped" : "tarot-flip"}>
|
||||
{i < filled ? (
|
||||
<div className="tarot-flip-inner">
|
||||
<TarotCardBack className="tarot-face tarot-back" />
|
||||
{card && <TarotCard card={card} reversed={drawn?.reversed} className="tarot-face tarot-front" />}
|
||||
</div>
|
||||
) : (
|
||||
<div className="tarot-slot-empty" aria-hidden="true" />
|
||||
)}
|
||||
</div>
|
||||
<span className="tarot-slot-title">{drawn?.position ?? `${i + 1}. lap`}</span>
|
||||
{flipped && card && (
|
||||
<span className="hint">
|
||||
{card.nameHu}
|
||||
{drawn?.reversed ? " · fordított" : ""}
|
||||
</span>
|
||||
)}
|
||||
</li>
|
||||
);
|
||||
})}
|
||||
</ol>
|
||||
);
|
||||
}
|
||||
@@ -4,15 +4,22 @@ import Link from "next/link";
|
||||
import { useCallback, useEffect, useState } from "react";
|
||||
|
||||
import { api, ApiError, errorText } from "@/lib/api";
|
||||
import { SPREADS, TAROT_QUESTION_MAX, tarotCard, type SpreadId, type TarotReading } from "@/lib/tarot";
|
||||
import {
|
||||
SPREADS,
|
||||
TAROT_QUESTION_MAX,
|
||||
TOPICS,
|
||||
tarotCard,
|
||||
type SpreadId,
|
||||
type TarotReading,
|
||||
type TopicId,
|
||||
} from "@/lib/tarot";
|
||||
import type { PayMethod, UnitBalance } from "@/lib/types";
|
||||
|
||||
import { PackageChooser } from "../PackageCards";
|
||||
import { TarotCard, TarotCardBack } from "./TarotCard";
|
||||
import { TarotCard } from "./TarotCard";
|
||||
import { TarotLive } from "./TarotLive";
|
||||
import { TarotFan, TarotSlots } from "./TarotSpread";
|
||||
|
||||
/** Face-down cards in the fan to pick from. */
|
||||
const FAN = 21;
|
||||
/** Pause between two cards turning over. */
|
||||
const REVEAL_MS = 650;
|
||||
|
||||
@@ -41,6 +48,7 @@ export function TarotTable({
|
||||
const [readings, setReadings] = useState(initialReadings);
|
||||
const [left, setLeft] = useState(initialLeft);
|
||||
const [spread, setSpread] = useState<SpreadId>("trinity");
|
||||
const [topic, setTopic] = useState<TopicId>("general");
|
||||
const [question, setQuestion] = useState("");
|
||||
const [phase, setPhase] = useState<Phase>("setup");
|
||||
const [picked, setPicked] = useState<number[]>([]);
|
||||
@@ -69,7 +77,7 @@ export function TarotTable({
|
||||
setError(null);
|
||||
try {
|
||||
const reading = await api<TarotReading>("/tarot/readings", {
|
||||
body: { spread, question: question.trim() || null },
|
||||
body: { spread, topic, question: question.trim() || null },
|
||||
});
|
||||
setCurrent(reading);
|
||||
setReadings((all) => [reading, ...all]);
|
||||
@@ -87,7 +95,7 @@ export function TarotTable({
|
||||
}
|
||||
}
|
||||
},
|
||||
[spread, question],
|
||||
[spread, topic, question],
|
||||
);
|
||||
|
||||
function pick(i: number) {
|
||||
@@ -152,6 +160,22 @@ export function TarotTable({
|
||||
</div>
|
||||
) : (
|
||||
<form className="field" style={{ gap: 18 }} onSubmit={start}>
|
||||
<fieldset className="tarot-topics">
|
||||
<legend className="label">Téma</legend>
|
||||
{TOPICS.map((t) => (
|
||||
<label key={t.id} className={t.id === topic ? "tarot-topic is-active" : "tarot-topic"}>
|
||||
<input
|
||||
type="radio"
|
||||
name="topic"
|
||||
value={t.id}
|
||||
checked={t.id === topic}
|
||||
onChange={() => setTopic(t.id)}
|
||||
className="sr-only"
|
||||
/>
|
||||
{t.name}
|
||||
</label>
|
||||
))}
|
||||
</fieldset>
|
||||
<fieldset className="tarot-spreads">
|
||||
<legend className="label">Kirakás</legend>
|
||||
{SPREADS.map((s) => (
|
||||
@@ -177,7 +201,7 @@ export function TarotTable({
|
||||
rows={2}
|
||||
maxLength={TAROT_QUESTION_MAX}
|
||||
value={question}
|
||||
placeholder="Pl. Mire figyeljek, ha munkahelyet váltanék? Kérdés nélkül általános útmutatást kapsz."
|
||||
placeholder={`${TOPICS.find((x) => x.id === topic)?.example ?? ""} Kérdés nélkül a témában kapsz útmutatást.`}
|
||||
onChange={(e) => setQuestion(e.target.value)}
|
||||
/>
|
||||
<span className="hint">
|
||||
@@ -209,7 +233,9 @@ export function TarotTable({
|
||||
{phase !== "setup" && (
|
||||
<section className="card tarot-stage" aria-labelledby="tarot-stage-title">
|
||||
<div className="tarot-stage-head">
|
||||
<span className="eyebrow">{current?.spread_name ?? chosen.name}</span>
|
||||
<span className="eyebrow">
|
||||
{current?.spread_name ?? chosen.name} · {current?.topic_name ?? TOPICS.find((x) => x.id === topic)?.name}
|
||||
</span>
|
||||
<h2 id="tarot-stage-title">
|
||||
{phase === "picking"
|
||||
? `Válassz ${chosen.cards} lapot a pakliból`
|
||||
@@ -224,52 +250,9 @@ export function TarotTable({
|
||||
</p>
|
||||
</div>
|
||||
|
||||
<ol className="tarot-slots" data-count={slots}>
|
||||
{Array.from({ length: slots }).map((_, i) => {
|
||||
const drawn = current?.cards[i];
|
||||
const card = drawn ? tarotCard(drawn.card) : undefined;
|
||||
const flipped = !!card && i < revealed;
|
||||
return (
|
||||
<li key={i} className="tarot-slot">
|
||||
<div className={flipped ? "tarot-flip is-flipped" : "tarot-flip"}>
|
||||
{i < picked.length || drawn ? (
|
||||
<div className="tarot-flip-inner">
|
||||
<TarotCardBack className="tarot-face tarot-back" />
|
||||
{card && <TarotCard card={card} reversed={drawn?.reversed} className="tarot-face tarot-front" />}
|
||||
</div>
|
||||
) : (
|
||||
<div className="tarot-slot-empty" aria-hidden="true" />
|
||||
)}
|
||||
</div>
|
||||
<span className="tarot-slot-title">{drawn?.position ?? `${i + 1}. lap`}</span>
|
||||
{flipped && card && (
|
||||
<span className="hint">
|
||||
{card.nameHu}
|
||||
{drawn?.reversed ? " · fordított" : ""}
|
||||
</span>
|
||||
)}
|
||||
</li>
|
||||
);
|
||||
})}
|
||||
</ol>
|
||||
<TarotSlots count={slots} filled={current ? slots : picked.length} cards={current?.cards} revealed={revealed} />
|
||||
|
||||
{phase === "picking" && (
|
||||
<div className="tarot-fan" role="group" aria-label="A megkevert pakli">
|
||||
{Array.from({ length: FAN }).map((_, i) => (
|
||||
<button
|
||||
key={i}
|
||||
type="button"
|
||||
className={picked.includes(i) ? "tarot-fan-card is-picked" : "tarot-fan-card"}
|
||||
style={{ "--i": i - (FAN - 1) / 2 } as React.CSSProperties}
|
||||
onClick={() => pick(i)}
|
||||
disabled={picked.includes(i)}
|
||||
aria-label={`${i + 1}. lap kiválasztása`}
|
||||
>
|
||||
<TarotCardBack />
|
||||
</button>
|
||||
))}
|
||||
</div>
|
||||
)}
|
||||
{phase === "picking" && <TarotFan picked={picked} onPick={pick} />}
|
||||
{phase === "picking" && (
|
||||
<div className="form-actions">
|
||||
<button type="button" className="btn btn-ghost" onClick={again}>
|
||||
@@ -310,7 +293,8 @@ export function TarotTable({
|
||||
<span className="tarot-history-text">
|
||||
<strong>{r.content?.title ?? r.question ?? r.spread_name}</strong>
|
||||
<span className="hint">
|
||||
{day(r.created_at)} · {r.spread_name}
|
||||
{day(r.created_at)} · {r.topic_name ? `${r.topic_name} · ` : ""}
|
||||
{r.spread_name}
|
||||
{r.question && r.content ? ` · „${r.question}”` : ""}
|
||||
{r.status === "pending" || r.status === "running" ? " · készül" : ""}
|
||||
{r.status === "failed" ? " · nem sikerült" : ""}
|
||||
|
||||
@@ -1,42 +1,110 @@
|
||||
{
|
||||
"signs": "Rák Nap, Halak Hold, Kos Aszcendens",
|
||||
"spread_name": "Sorsfonalak hármas",
|
||||
"question": "Hogyan találhatnék több örömöt a munkámban?",
|
||||
"cards": [
|
||||
"examples": [
|
||||
{
|
||||
"card": "major-2",
|
||||
"reversed": false,
|
||||
"position": "Gyökér és előzmény",
|
||||
"about": "Honnan ered a mostani helyzet energiája."
|
||||
},
|
||||
{
|
||||
"card": "pentacles-8",
|
||||
"reversed": true,
|
||||
"position": "Jelenlegi fókusz",
|
||||
"about": "Mi zajlik most a felszínen és a mélyben."
|
||||
},
|
||||
{
|
||||
"card": "major-17",
|
||||
"reversed": false,
|
||||
"position": "Kibontakozás",
|
||||
"about": "Merre tart a folyamat, ha tudatosan együttműködsz vele."
|
||||
}
|
||||
],
|
||||
"content": {
|
||||
"title": "A csendes tudástól a tiszta reményig",
|
||||
"summary": "A lapok azt mutatják, hogy az öröm nem a több munkából, hanem a belső iránytűd újbóli meghallásából jön vissza. A Főpapnőtől a Csillagig vezető út arról szól, hogy a tökéletességre törekvés helyett engedd vissza a munkádba azt, ami eredetileg is megmozdított.",
|
||||
"cards": [
|
||||
{
|
||||
"body": "A Főpapnő a helyzet gyökerénél áll: valahol mélyen pontosan tudod, mi az, ami a munkádban igazán táplál, csak ez a tudás az utóbbi időben elcsendesedett. Ez a lap a megérzés, a megfigyelés és a belső hang kártyája, és most azt jelzi, hogy az elégedetlenséged forrása nem kívül van. Inkább abban, hogy a teendők zajában kevesebb tér maradt a saját ritmusodnak.\n\nA Főpapnő a Holdhoz tartozik, és ez a te Halak Holdaddal együtt különösen beszédes: neked az érzelmi rezonancia nem luxus, hanem üzemanyag. Ha egy feladat nem szól a lelkedhez is, akkor hiába végzed jól, kiürít."
|
||||
},
|
||||
{
|
||||
"body": "Az Érmék 8 fordított állásban a jelen fókuszát mutatja: sok energiát teszel abba, hogy minden részlet rendben legyen, de a gondosság észrevétlenül perfekcionizmussá vált. A munka ilyenkor ismétlődő gyakorlattá szürkül, és a mesterség öröme helyére a megfelelés feszültsége lép.\n\nEz a lap nem azt kéri, hogy engedd el a minőséget. Azt kéri, hogy válaszd szét a fontosat a csak megszokottól. Hol csiszolsz valamit tovább, mint amennyit a cél kíván? Ott szabadulhat fel a legtöbb idő és kedv."
|
||||
},
|
||||
{
|
||||
"body": "A Csillag a kibontakozás helyén a pakli egyik legreményteljesebb lapja. A vihar utáni csendes megújulást jelzi: ha tudatosan együttműködsz a folyamattal, a munkádhoz való viszonyod újra tisztává és inspirálóvá válhat. A Csillag nem gyors fordulatot ígér, hanem azt, hogy visszatalálsz a saját jövőképedhez.\n\nA Vízöntőhöz kapcsolódó lapként arra is utal, hogy az öröm egy része közösségből, megosztásból fakadhat: olyan emberekből és ötletekből, akik és amik tágítják a látókörödet."
|
||||
"id": "munka",
|
||||
"label": "Munka",
|
||||
"signs": "Rák Nap, Halak Hold, Kos Aszcendens",
|
||||
"spread_name": "Sorsfonalak hármas",
|
||||
"question": "Hogyan találhatnék több örömöt a munkámban?",
|
||||
"cards": [
|
||||
{
|
||||
"card": "major-2",
|
||||
"reversed": false,
|
||||
"position": "Gyökér és előzmény",
|
||||
"about": "Honnan ered a mostani helyzet energiája."
|
||||
},
|
||||
{
|
||||
"card": "pentacles-8",
|
||||
"reversed": true,
|
||||
"position": "Jelenlegi fókusz",
|
||||
"about": "Mi zajlik most a felszínen és a mélyben."
|
||||
},
|
||||
{
|
||||
"card": "major-17",
|
||||
"reversed": false,
|
||||
"position": "Kibontakozás",
|
||||
"about": "Merre tart a folyamat, ha tudatosan együttműködsz vele."
|
||||
}
|
||||
],
|
||||
"content": {
|
||||
"title": "A csendes tudástól a tiszta reményig",
|
||||
"summary": "A lapok azt mutatják, hogy az öröm nem a több munkából, hanem a belső iránytűd újbóli meghallásából jön vissza. A Főpapnőtől a Csillagig vezető út arról szól, hogy a tökéletességre törekvés helyett engedd vissza a munkádba azt, ami eredetileg is megmozdított.",
|
||||
"cards": [
|
||||
{
|
||||
"body": "A Főpapnő a helyzet gyökerénél áll: valahol mélyen pontosan tudod, mi az, ami a munkádban igazán táplál, csak ez a tudás az utóbbi időben elcsendesedett. Ez a lap a megérzés, a megfigyelés és a belső hang kártyája, és most azt jelzi, hogy az elégedetlenséged forrása nem kívül van. Inkább abban, hogy a teendők zajában kevesebb tér maradt a saját ritmusodnak.\n\nA Főpapnő a Holdhoz tartozik, és ez a te Halak Holdaddal együtt különösen beszédes: neked az érzelmi rezonancia nem luxus, hanem üzemanyag. Ha egy feladat nem szól a lelkedhez is, akkor hiába végzed jól, kiürít."
|
||||
},
|
||||
{
|
||||
"body": "Az Érmék 8 fordított állásban a jelen fókuszát mutatja: sok energiát teszel abba, hogy minden részlet rendben legyen, de a gondosság észrevétlenül perfekcionizmussá vált. A munka ilyenkor ismétlődő gyakorlattá szürkül, és a mesterség öröme helyére a megfelelés feszültsége lép.\n\nEz a lap nem azt kéri, hogy engedd el a minőséget. Azt kéri, hogy válaszd szét a fontosat a csak megszokottól. Hol csiszolsz valamit tovább, mint amennyit a cél kíván? Ott szabadulhat fel a legtöbb idő és kedv."
|
||||
},
|
||||
{
|
||||
"body": "A Csillag a kibontakozás helyén a pakli egyik legreményteljesebb lapja. A vihar utáni csendes megújulást jelzi: ha tudatosan együttműködsz a folyamattal, a munkádhoz való viszonyod újra tisztává és inspirálóvá válhat. A Csillag nem gyors fordulatot ígér, hanem azt, hogy visszatalálsz a saját jövőképedhez.\n\nA Vízöntőhöz kapcsolódó lapként arra is utal, hogy az öröm egy része közösségből, megosztásból fakadhat: olyan emberekből és ötletekből, akik és amik tágítják a látókörödet."
|
||||
}
|
||||
],
|
||||
"synthesis": "A három lap egy belső ív történetét meséli el: a Főpapnő csendes tudásától a fordított Érmék 8 túlhajszolt aprólékosságán át a Csillag nyitott, reménnyel teli jövőképéig. Két nagy árkánum fogja közre a hétköznapi munkát jelző kis lapot, ami azt üzeni, hogy a mostani elakadás egy nagyobb, értelmes változás része.\n\nA lapokban a Víz és a Levegő dominál, a Föld csak a fordított lapon jelenik meg. A te Kos Aszcendensed lendülete akkor segít a legtöbbet, ha nem több feladat elvállalására fordítod, hanem bátor, kicsi változtatásokra: arra, hogy kimondd, mi érdekel igazán.",
|
||||
"advice": "Ezen a héten jelölj ki egyetlen feladatot, amelyet szándékosan „elég jóra” csinálsz meg, és figyeld meg, mit kezdesz a felszabaduló idővel. Írd le három olyan pillanatodat a munkából, amikor az utóbbi években igazán elevennek érezted magad, és keresd meg, mi a közös bennük: ez a Főpapnő csendes tudása, amelyre a Csillag útja épülhet."
|
||||
}
|
||||
],
|
||||
"synthesis": "A három lap egy belső ív történetét meséli el: a Főpapnő csendes tudásától a fordított Érmék 8 túlhajszolt aprólékosságán át a Csillag nyitott, reménnyel teli jövőképéig. Két nagy árkánum fogja közre a hétköznapi munkát jelző kis lapot, ami azt üzeni, hogy a mostani elakadás egy nagyobb, értelmes változás része.\n\nA lapokban a Víz és a Levegő dominál, a Föld csak a fordított lapon jelenik meg. A te Kos Aszcendensed lendülete akkor segít a legtöbbet, ha nem több feladat elvállalására fordítod, hanem bátor, kicsi változtatásokra: arra, hogy kimondd, mi érdekel igazán.",
|
||||
"advice": "Ezen a héten jelölj ki egyetlen feladatot, amelyet szándékosan „elég jóra” csinálsz meg, és figyeld meg, mit kezdesz a felszabaduló idővel. Írd le három olyan pillanatodat a munkából, amikor az utóbbi években igazán elevennek érezted magad, és keresd meg, mi a közös bennük: ez a Főpapnő csendes tudása, amelyre a Csillag útja épülhet."
|
||||
}
|
||||
},
|
||||
{
|
||||
"id": "parkapcsolat",
|
||||
"label": "Párkapcsolat",
|
||||
"signs": "Mérleg Nap, Bika Hold, Oroszlán Aszcendens",
|
||||
"spread_name": "Képlet-kereszt",
|
||||
"question": "Merre tart a kapcsolatunk, és mit tehetek azért, hogy közelebb kerüljünk egymáshoz?",
|
||||
"cards": [
|
||||
{
|
||||
"card": "cups-2",
|
||||
"reversed": false,
|
||||
"position": "Központi téma",
|
||||
"about": "A kérdés szíve és a jelenlegi sorspont."
|
||||
},
|
||||
{
|
||||
"card": "major-18",
|
||||
"reversed": true,
|
||||
"position": "Hold-mélység (belső)",
|
||||
"about": "Tudattalan érzelmi mozgatórugók és megérzések."
|
||||
},
|
||||
{
|
||||
"card": "major-6",
|
||||
"reversed": false,
|
||||
"position": "Nap-tér (tudatos)",
|
||||
"about": "Amire már rálátsz, és ami felé az akaratod irányul."
|
||||
},
|
||||
{
|
||||
"card": "wands-5",
|
||||
"reversed": false,
|
||||
"position": "Kvadrát (kihívás)",
|
||||
"about": "A súrlódás, amely cselekvésre és növekedésre hív."
|
||||
},
|
||||
{
|
||||
"card": "major-3",
|
||||
"reversed": false,
|
||||
"position": "Aszcendens (útmutatás)",
|
||||
"about": "A legtisztább következő lépés kifelé és előre."
|
||||
}
|
||||
],
|
||||
"content": {
|
||||
"title": "Két kehely, egy közös forrás",
|
||||
"summary": "A kirakás szíve a Kelyhek 2: a kapcsolatotok alapja a kölcsönös vonzalom és az egyenrangúság, és ez most is él. A lapok azt mutatják, hogy a közelség nem nagy gesztusokon múlik, hanem azon, hogy a súrlódásokat ne erőpróbaként, hanem közös alkotásként éljétek meg, és több gyengédséget engedjetek a hétköznapokba.",
|
||||
"cards": [
|
||||
{
|
||||
"body": "A Kelyhek 2 a kirakás közepén a pakli egyik legszebb kapcsolati lapja: két ember, aki egyenrangú félként nyújtja egymás felé a poharát. Azt jelzi, hogy a kérdésed mögött nem kiürült kötelék, hanem egy élő szövetség áll, amelyben mindkettőtöknek van mit adnia.\n\nA lap a Vénuszhoz kapcsolódik, és ez a te Mérleg Napoddal különösen összecseng: neked a kapcsolat akkor teljes, ha az adok-kapok egyensúlyban van. Ha mostanában távolabbinak érzed a másikat, az nem a szeretet hiánya, hanem jelzés arra, hogy az egyensúly egy ponton elcsúszott, és újra be lehet állítani."
|
||||
},
|
||||
{
|
||||
"body": "A Hold fordítottan a belső mélységek helyén azt mutatja, hogy egy régebbi bizonytalanság, talán egy kimondatlan félelem vagy félreértés köde éppen oszlani kezd. Lehet, hogy egy ideje inkább találgattál, mit érez a másik, mint hogy megkérdezted volna.\n\nEz a lap megkönnyebbülést hoz: amit eddig csak sejtettél, az most tisztábban látható. A Bika Holdad biztonságra és kézzelfogható jelekre vágyik. Engedd meg magadnak, hogy ezt kimondd, ahelyett hogy a csendből próbálnád kiolvasni a választ."
|
||||
},
|
||||
{
|
||||
"body": "A Szeretők a tudatos szándék helyén azt jelzi, hogy belül már döntöttél: ezt a kapcsolatot választod, és szeretnéd, hogy mélyebb legyen. Ez a lap azonban nemcsak szerelemről, hanem önazonosságról is szól. A valódi közelség ott kezdődik, ahol nem kell feladnod önmagadat a harmóniáért.\n\nMérleg Napként hajlamos lehetsz a béke kedvéért elsimítani a saját igényeidet. A Szeretők most arra bátorít, hogy a választásod mellé add oda azt is, ami neked fontos: így a másik az igazi énedhez tud közelebb kerülni."
|
||||
},
|
||||
{
|
||||
"body": "A Botok 5 a kihívás helyén élénk súrlódást mutat: viták, apró versengések arról, kinek van igaza, kinek az elképzelése valósul meg. Ez a lap nem ellenségeskedést jelez, hanem két erős akarat találkozását, amelyben sok a fel nem használt energia.\n\nAz Oroszlán Aszcendensed és a lap Oroszlánhoz kötődő megfelelése is azt súgja, hogy a büszkeség néha többet szól, mint a szív. A kérdés nem az, hogy ki nyer, hanem hogy ezt a lendületet tudjátok-e egy közös cél felé fordítani: egy terv, egy kaland vagy egy alkotás felé, amelyben egy oldalon álltok."
|
||||
},
|
||||
{
|
||||
"body": "Az Uralkodónő az útmutatás helyén a legmelegebb tanácsot adja: a közelség gondoskodásból, érzékiségből és apró, tápláló figyelmességekből nő. Ez a lap a bőség és a növekedés kártyája. Azt mutatja, hogy ami most kell a kapcsolatotoknak, az nem több elemzés, hanem több megélt, közös öröm.\n\nA Vénuszhoz tartozó Uralkodónő a Bika Holdad nyelvén beszél: egy közösen elkészített vacsora, egy séta, egy érintés néha többet mond bármilyen beszélgetésnél. Ha te is táplálva érzed magad, a gondoskodásod sem merül ki."
|
||||
}
|
||||
],
|
||||
"synthesis": "A kirakásban három nagy árkánum vesz körül két kis lapot, ami azt jelzi, hogy a kapcsolatotok most egy fontos, mélyülő szakaszban van. A Kelyhek 2 és a Szeretők ugyanazt mondja két nyelven: a köteléketek valódi, és mindketten választjátok. A fordított Hold azt mutatja, hogy a belső bizonytalanság oldódik, a Botok 5 pedig megmutatja, hol szivárog el az energia: a felesleges erőpróbákban.\n\nA lapokban a Víz és a Levegő mellett a Tűz és a Föld is megjelenik, vagyis minden megvan, ami egy kiegyensúlyozott kapcsolathoz kell: érzés, szó, lendület és gondoskodás. A te dolgod most az, hogy ezeket ne egymás ellen, hanem egymás mellett használd.",
|
||||
"advice": "Ezen a héten mondj ki egy olyan kívánságot, amelyet eddig a béke kedvéért megtartottál magadnak, kérésként, nem szemrehányásként. A következő vitánál pedig állj meg egy pillanatra, és kérdezd meg: „Mit szeretnénk mi ketten ebből kihozni?” Közben teremts egy apró, közös örömforrást, amely csak a tiétek: az Uralkodónő ebből a kertből nő."
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -43,6 +43,16 @@ export const SPREADS: { id: SpreadId; name: string; cards: number; about: string
|
||||
},
|
||||
];
|
||||
|
||||
export type TopicId = "general" | "love" | "work" | "self";
|
||||
|
||||
/** What a reading is about (the backend's `TOPICS`), with an example question. */
|
||||
export const TOPICS: { id: TopicId; name: string; example: string }[] = [
|
||||
{ id: "general", name: "Általános", example: "Pl. Mire figyeljek a következő hetekben?" },
|
||||
{ id: "love", name: "Párkapcsolat", example: "Pl. Mit tehetek azért, hogy közelebb kerüljünk egymáshoz?" },
|
||||
{ id: "work", name: "Munka és hivatás", example: "Pl. Mire figyeljek, ha munkahelyet váltanék?" },
|
||||
{ id: "self", name: "Önismeret", example: "Pl. Mit tanulhatok most önmagamról?" },
|
||||
];
|
||||
|
||||
/** Longest question (the backend's `TAROT_QUESTION_MAX_CHARS`). */
|
||||
export const TAROT_QUESTION_MAX = 300;
|
||||
|
||||
@@ -60,6 +70,8 @@ export interface TarotReading {
|
||||
status: "pending" | "running" | "done" | "failed";
|
||||
spread: SpreadId;
|
||||
spread_name: string | null;
|
||||
topic: TopicId | null;
|
||||
topic_name: string | null;
|
||||
question: string | null;
|
||||
cards: { card: string; reversed: boolean; position: string | null; about: string | null }[];
|
||||
content: TarotContent | null;
|
||||
|
||||
@@ -94,6 +94,8 @@ export interface Question {
|
||||
|
||||
export interface PublicConfig {
|
||||
google_login: { enabled: boolean; client_id: string | null };
|
||||
/** Sign in with Apple; `client_id` is the Services ID. */
|
||||
apple_login?: { enabled: boolean; client_id: string | null };
|
||||
locales: string[];
|
||||
password_login: boolean;
|
||||
password_min_length: number;
|
||||
|
||||
@@ -54,7 +54,7 @@ async fn main() -> anyhow::Result<()> {
|
||||
if std::env::args().nth(1).as_deref() == Some("healthcheck") {
|
||||
return service_kit::healthcheck(addr);
|
||||
}
|
||||
service_kit::init_logging();
|
||||
let _log = service_kit::init_logging("horoscope-api");
|
||||
let state = Arc::new(tokio::task::spawn_blocking(load_state).await??);
|
||||
let app = routes::router(state);
|
||||
let listener = tokio::net::TcpListener::bind(addr).await.with_context(|| format!("binding {addr}"))?;
|
||||
|
||||
@@ -9,8 +9,7 @@ use axum::{Json, Router};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::{Value, json};
|
||||
use tower_http::cors::{AllowOrigin, Any, CorsLayer};
|
||||
use tower_http::trace::{DefaultMakeSpan, DefaultOnResponse, TraceLayer};
|
||||
use tracing::Level;
|
||||
use tower_http::trace::TraceLayer;
|
||||
|
||||
use crate::AppState;
|
||||
use crate::error::ApiError;
|
||||
@@ -31,11 +30,8 @@ pub fn router(state: Arc<AppState>) -> Router {
|
||||
.route("/v1/synastry", post(synastry_chart))
|
||||
.route("/v1/forecast", post(forecast_year))
|
||||
.layer(cors())
|
||||
.layer(
|
||||
TraceLayer::new_for_http()
|
||||
.make_span_with(DefaultMakeSpan::new().level(Level::INFO))
|
||||
.on_response(DefaultOnResponse::new().level(Level::INFO)),
|
||||
)
|
||||
// The request log: masked paths, health checks only when they fail.
|
||||
.layer(TraceLayer::new_for_http().make_span_with(service_kit::RequestLog).on_response(service_kit::RequestLog))
|
||||
.with_state(state)
|
||||
}
|
||||
|
||||
|
||||
@@ -16,10 +16,13 @@ RUN --mount=type=cache,target=/usr/local/cargo/registry,sharing=locked \
|
||||
--mount=type=cache,target=/app/target,sharing=locked \
|
||||
cargo build --release --locked -p worker \
|
||||
&& cp target/release/worker /worker
|
||||
# The log directory (LOG_DIR); a volume mounted here takes over its owner.
|
||||
RUN mkdir /logs
|
||||
|
||||
# --- 2. runtime: the binary only (TLS roots are compiled in via webpki-roots) ---
|
||||
FROM scratch
|
||||
COPY --from=build /worker /worker
|
||||
COPY --from=build --chown=65532:65532 /logs /logs
|
||||
ENV BIND_ADDR=0.0.0.0:8082 \
|
||||
LOG_FORMAT=json \
|
||||
RUST_LOG=info
|
||||
|
||||
@@ -334,6 +334,8 @@ impl Analyzer {
|
||||
result = work => result,
|
||||
() = self.superseded("analyses", job.id, job.started_at) => {
|
||||
tracing::info!(id = %job.id, "analysis restarted by an admin; this attempt is dropped");
|
||||
// Not ours any more: a stop must not hand it back to the queue.
|
||||
self.running.lock().unwrap().remove(&job.id);
|
||||
return;
|
||||
}
|
||||
};
|
||||
@@ -611,7 +613,7 @@ impl Analyzer {
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn run(analyzer: Arc<Analyzer>, poll: Duration, stop: watch::Receiver<bool>) {
|
||||
pub async fn run(analyzer: Arc<Analyzer>, poll: Duration, drain: Duration, stop: watch::Receiver<bool>) {
|
||||
let quick = Arc::new(Semaphore::new(analyzer.lanes.quick));
|
||||
let slow = Arc::new(Semaphore::new(analyzer.lanes.slow));
|
||||
let mut tasks = tokio::task::JoinSet::new();
|
||||
@@ -662,8 +664,12 @@ pub async fn run(analyzer: Arc<Analyzer>, poll: Duration, stop: watch::Receiver<
|
||||
() = crate::stopped(stop.clone()) => break,
|
||||
}
|
||||
}
|
||||
// Give running analyses a moment, then hand the rest back to the queue.
|
||||
let _ = tokio::time::timeout(Duration::from_secs(10), async { while tasks.join_next().await.is_some() {} }).await;
|
||||
// Let running analyses finish within the drain time, then hand the rest
|
||||
// back to the queue (without counting the attempt).
|
||||
if !tasks.is_empty() {
|
||||
tracing::info!(running = tasks.len(), drain_secs = drain.as_secs(), "waiting for running analyses");
|
||||
}
|
||||
let _ = tokio::time::timeout(drain, async { while tasks.join_next().await.is_some() {} }).await;
|
||||
tasks.abort_all();
|
||||
analyzer.release_running().await;
|
||||
}
|
||||
|
||||
@@ -111,6 +111,8 @@ impl Analyzer {
|
||||
result = work => result,
|
||||
() = self.superseded("questions", job.id, job.started_at) => {
|
||||
tracing::info!(id = %job.id, "answer restarted by an admin; this attempt is dropped");
|
||||
// Not ours any more: a stop must not hand it back to the queue.
|
||||
self.running.lock().unwrap().remove(&job.id);
|
||||
return;
|
||||
}
|
||||
};
|
||||
|
||||
@@ -52,6 +52,11 @@ pub struct Config {
|
||||
pub mail_from: Mailbox,
|
||||
/// Fallback polling interval; new e-mails are picked up at once via LISTEN/NOTIFY.
|
||||
pub poll_interval: Duration,
|
||||
/// On a stop (a deploy): how long running work may still finish, taking
|
||||
/// nothing new (`SHUTDOWN_DRAIN_SECS`, default 20); analyses not done by
|
||||
/// then go back to the queue. Keep it below the container's stop grace
|
||||
/// period (`stop_grace_period` in compose, Docker's default is 10 s).
|
||||
pub shutdown_drain: Duration,
|
||||
/// After this many failed attempts an e-mail is marked as failed.
|
||||
pub max_email_attempts: i32,
|
||||
/// Unset: analyses stay pending.
|
||||
@@ -107,6 +112,7 @@ impl Config {
|
||||
smtp_about,
|
||||
mail_from: mail_from.parse().with_context(|| format!("invalid MAIL_FROM '{mail_from}'"))?,
|
||||
poll_interval: Duration::from_secs(parsed("POLL_INTERVAL_SECS", 30)?),
|
||||
shutdown_drain: Duration::from_secs(parsed("SHUTDOWN_DRAIN_SECS", 20)?),
|
||||
max_email_attempts: parsed("MAX_EMAIL_ATTEMPTS", 8)?,
|
||||
// The lower-case name is accepted too (as written in some secrets files).
|
||||
openrouter_api_key: var("OPENROUTER_API_KEY").or_else(|| var("openrouter_api_key")),
|
||||
|
||||
+147
-25
@@ -4,9 +4,12 @@
|
||||
//! the item as they go on the invoice. This job takes the due rows and, step
|
||||
//! by step, creates the Billingo partner, the invoice (paid by card,
|
||||
//! electronic) and e-mails it to the buyer. Each step's result is saved before
|
||||
//! the next one, so a retry continues where it stopped and never issues a
|
||||
//! second invoice. Billingo's whole answer is kept; the PDF is not (the
|
||||
//! backend fetches it when the user downloads it).
|
||||
//! the next one, so a retry continues where it stopped. The invoice request is
|
||||
//! marked before it is sent: when Billingo's answer was lost, the retry finds
|
||||
//! the invoice under the invoice's own partner instead of issuing a second
|
||||
//! one. An invoice that was issued but could not be e-mailed still counts as
|
||||
//! issued (it can be downloaded). Billingo's whole answer is kept; the PDF is
|
||||
//! not (the backend fetches it when the user downloads it).
|
||||
|
||||
use std::time::Duration;
|
||||
|
||||
@@ -93,6 +96,7 @@ struct Due {
|
||||
payment_method: String,
|
||||
billingo_partner_id: Option<i64>,
|
||||
billingo_document_id: Option<i64>,
|
||||
document_requested_at: Option<OffsetDateTime>,
|
||||
sent_at: Option<OffsetDateTime>,
|
||||
paid_at: OffsetDateTime,
|
||||
}
|
||||
@@ -131,7 +135,8 @@ pub async fn run_once(db: &PgPool, billingo: &Billingo, max_attempts: i32) -> Re
|
||||
AND next_attempt_at <= now() ORDER BY next_attempt_at FOR UPDATE SKIP LOCKED LIMIT 1) \
|
||||
RETURNING i.id, i.attempts, i.buyer_name, i.buyer_email, i.buyer_country, i.buyer_post_code, \
|
||||
i.buyer_city, i.buyer_address, i.buyer_tax_type, i.buyer_tax_number, i.item_name, i.item_comment, i.item_unit, i.gross_huf, \
|
||||
i.vat_rate, i.payment_method, i.billingo_partner_id, i.billingo_document_id, i.sent_at, \
|
||||
i.vat_rate, i.payment_method, i.billingo_partner_id, i.billingo_document_id, \
|
||||
i.document_requested_at, i.sent_at, \
|
||||
coalesce(c.completed_at, i.created_at) AS paid_at"
|
||||
))
|
||||
.fetch_optional(db)
|
||||
@@ -144,12 +149,28 @@ pub async fn run_once(db: &PgPool, billingo: &Billingo, max_attempts: i32) -> Re
|
||||
}
|
||||
Err(Failure::Db(e)) => return Err(e),
|
||||
Err(Failure::Billingo(error)) if due.attempts >= max_attempts => {
|
||||
tracing::error!(invoice = %due.id, %error, "invoice failed; an admin has to look at it");
|
||||
sqlx::query("UPDATE invoices SET status = 'failed', last_error = $2 WHERE id = $1")
|
||||
.bind(due.id)
|
||||
.bind(&error)
|
||||
.execute(db)
|
||||
.await?;
|
||||
// Issued but never e-mailed: it is still an invoice (the user downloads it).
|
||||
let issued: Option<(Option<String>,)> = sqlx::query_as(
|
||||
"UPDATE invoices SET status = 'issued', issued_at = now(), last_error = $2 \
|
||||
WHERE id = $1 AND billingo_document_id IS NOT NULL RETURNING invoice_number",
|
||||
)
|
||||
.bind(due.id)
|
||||
.bind(format!("issued, not e-mailed: {error}"))
|
||||
.fetch_optional(db)
|
||||
.await?;
|
||||
match issued {
|
||||
Some((number,)) => {
|
||||
tracing::warn!(invoice = %due.id, number = ?number, %error, "invoice issued but not e-mailed")
|
||||
}
|
||||
None => {
|
||||
tracing::error!(invoice = %due.id, %error, "invoice failed; an admin has to look at it");
|
||||
sqlx::query("UPDATE invoices SET status = 'failed', last_error = $2 WHERE id = $1")
|
||||
.bind(due.id)
|
||||
.bind(&error)
|
||||
.execute(db)
|
||||
.await?;
|
||||
}
|
||||
}
|
||||
done += 1;
|
||||
}
|
||||
Err(Failure::Billingo(error)) => {
|
||||
@@ -208,7 +229,13 @@ async fn issue(db: &PgPool, billingo: &Billingo, due: &Due) -> Result<String, Fa
|
||||
"address": due.buyer_address,
|
||||
},
|
||||
"emails": due.buyer_email.iter().collect::<Vec<_>>(),
|
||||
"taxcode": due.buyer_tax_number.clone().unwrap_or_default(),
|
||||
// Without a tax type number (a Hungarian company with only an
|
||||
// EU VAT number) the number goes into the invoice's comment.
|
||||
"taxcode": if due.buyer_tax_type == "NO_TAX_NUMBER" {
|
||||
String::new()
|
||||
} else {
|
||||
due.buyer_tax_number.clone().unwrap_or_default()
|
||||
},
|
||||
"tax_type": due.buyer_tax_type,
|
||||
});
|
||||
let partner = billingo.call(Method::POST, "/partners", Some(&body)).await?;
|
||||
@@ -246,13 +273,28 @@ async fn issue(db: &PgPool, billingo: &Billingo, due: &Due) -> Result<String, Fa
|
||||
"vat": due.vat_rate,
|
||||
"comment": due.item_comment.clone().unwrap_or_default(),
|
||||
}],
|
||||
"comment": if due.vat_rate == "AAM" {
|
||||
"Bankkártyával kifizetve (Stripe). Alanyi adómentes."
|
||||
} else {
|
||||
"Bankkártyával kifizetve (Stripe)."
|
||||
},
|
||||
"comment": document_comment(due),
|
||||
});
|
||||
let doc = billingo.call(Method::POST, "/documents", Some(&body)).await?;
|
||||
// An earlier attempt asked already: its invoice may exist although
|
||||
// the answer never came. The partner is this invoice's own, so any
|
||||
// invoice of it is ours.
|
||||
let earlier = match due.document_requested_at {
|
||||
Some(_) => find_document(billingo, partner).await?,
|
||||
None => None,
|
||||
};
|
||||
let doc = match earlier {
|
||||
Some(doc) => {
|
||||
tracing::warn!(invoice = %due.id, number = ?doc["invoice_number"], "found the invoice of an earlier attempt");
|
||||
doc
|
||||
}
|
||||
None => {
|
||||
sqlx::query("UPDATE invoices SET document_requested_at = now() WHERE id = $1")
|
||||
.bind(due.id)
|
||||
.execute(db)
|
||||
.await?;
|
||||
billingo.call(Method::POST, "/documents", Some(&body)).await?
|
||||
}
|
||||
};
|
||||
let id = doc["id"].as_i64().ok_or("Billingo invoice without id")?;
|
||||
let item = &doc["items"][0];
|
||||
sqlx::query(
|
||||
@@ -293,6 +335,34 @@ async fn issue(db: &PgPool, billingo: &Billingo, due: &Due) -> Result<String, Fa
|
||||
Ok(number.unwrap_or_default())
|
||||
}
|
||||
|
||||
/// The invoice's comment: how it was paid, the VAT exemption, and a
|
||||
/// Hungarian company's EU VAT number when it gave no domestic one.
|
||||
fn document_comment(due: &Due) -> String {
|
||||
let mut comment = String::from("Bankkártyával kifizetve (Stripe).");
|
||||
if due.vat_rate == "AAM" {
|
||||
comment.push_str(" Alanyi adómentes.");
|
||||
}
|
||||
if due.buyer_tax_type == "NO_TAX_NUMBER"
|
||||
&& let Some(eu) = &due.buyer_tax_number
|
||||
{
|
||||
comment.push_str(&format!(" A vevő közösségi adószáma: {eu}."));
|
||||
}
|
||||
comment
|
||||
}
|
||||
|
||||
/// The invoice already issued to `partner`, if any (an error is a failed
|
||||
/// attempt: an invoice is never made without knowing there is none).
|
||||
async fn find_document(billingo: &Billingo, partner: i64) -> Result<Option<Value>, Failure> {
|
||||
let list = billingo
|
||||
.call(reqwest::Method::GET, &format!("/documents?partner_id={partner}&type=invoice&per_page=10"), None)
|
||||
.await?;
|
||||
let items = list["data"].as_array().or_else(|| list.as_array()).ok_or("Billingo document list without data")?;
|
||||
Ok(items
|
||||
.iter()
|
||||
.find(|d| d["id"].as_i64().is_some() && d["partner"]["id"].as_i64().is_none_or(|p| p == partner))
|
||||
.cloned())
|
||||
}
|
||||
|
||||
pub async fn run(db: PgPool, billingo: Billingo, max_attempts: i32, interval: Duration, stop: watch::Receiver<bool>) {
|
||||
loop {
|
||||
if let Err(e) = run_once(&db, &billingo, max_attempts).await {
|
||||
@@ -338,6 +408,10 @@ mod tests {
|
||||
send_failures: AtomicUsize,
|
||||
/// Partners are refused (a permanent error).
|
||||
refuse_partners: std::sync::atomic::AtomicBool,
|
||||
/// The next invoice is made, but its answer is lost (an error instead).
|
||||
lose_document_answer: std::sync::atomic::AtomicBool,
|
||||
/// The invoices made so far, for the list.
|
||||
made: std::sync::Mutex<Vec<Value>>,
|
||||
}
|
||||
|
||||
async fn fake_billingo(fake: Arc<Fake>) -> String {
|
||||
@@ -355,13 +429,25 @@ mod tests {
|
||||
async fn document(State(f): State<Arc<Fake>>, Json(body): Json<Value>) -> (StatusCode, Json<Value>) {
|
||||
f.requests.lock().unwrap().push(("document".into(), body.clone()));
|
||||
let n = f.documents.fetch_add(1, Ordering::SeqCst) + 1;
|
||||
(
|
||||
StatusCode::CREATED,
|
||||
Json(json!({"id": 900 + n, "invoice_number": format!("SF-2026-{n}"), "invoice_date": "2026-11-20",
|
||||
"fulfillment_date": body["fulfillment_date"], "due_date": body["due_date"],
|
||||
"gross_total": 6000.0,
|
||||
"items": [{"name": "x", "net_amount": 6000.0, "vat_amount": 0.0, "gross_amount": 6000.0}]})),
|
||||
)
|
||||
let doc = json!({"id": 900 + n, "invoice_number": format!("SF-2026-{n}"), "invoice_date": "2026-11-20",
|
||||
"fulfillment_date": body["fulfillment_date"], "due_date": body["due_date"],
|
||||
"gross_total": 6000.0, "partner": {"id": body["partner_id"]},
|
||||
"items": [{"name": "x", "net_amount": 6000.0, "vat_amount": 0.0, "gross_amount": 6000.0}]});
|
||||
f.made.lock().unwrap().push(doc.clone());
|
||||
if f.lose_document_answer.swap(false, Ordering::SeqCst) {
|
||||
return (StatusCode::GATEWAY_TIMEOUT, Json(json!({"error": "timeout"})));
|
||||
}
|
||||
(StatusCode::CREATED, Json(doc))
|
||||
}
|
||||
async fn documents(
|
||||
State(f): State<Arc<Fake>>,
|
||||
axum::extract::Query(q): axum::extract::Query<std::collections::HashMap<String, String>>,
|
||||
) -> Json<Value> {
|
||||
f.requests.lock().unwrap().push(("list".into(), json!(q)));
|
||||
let partner: i64 = q.get("partner_id").and_then(|p| p.parse().ok()).unwrap_or(-1);
|
||||
let data: Vec<Value> =
|
||||
f.made.lock().unwrap().iter().filter(|d| d["partner"]["id"] == partner).cloned().collect();
|
||||
Json(json!({"data": data, "total": data.len()}))
|
||||
}
|
||||
async fn send(
|
||||
State(f): State<Arc<Fake>>,
|
||||
@@ -378,7 +464,7 @@ mod tests {
|
||||
let app = Router::new()
|
||||
.route("/document-blocks", get(blocks))
|
||||
.route("/partners", post(partner))
|
||||
.route("/documents", post(document))
|
||||
.route("/documents", post(document).get(documents))
|
||||
.route("/documents/{id}/send", post(send))
|
||||
.with_state(fake);
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
@@ -497,4 +583,40 @@ mod tests {
|
||||
assert!(error.contains("422") && error.contains("invalid tax code"), "{error}");
|
||||
assert_eq!(fake.documents.load(Ordering::SeqCst), 0);
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn a_lost_answer_does_not_make_a_second_invoice(db: PgPool) {
|
||||
let fake = Arc::new(Fake::default());
|
||||
fake.lose_document_answer.store(true, Ordering::SeqCst);
|
||||
let billingo = Billingo::new(&fake_billingo(fake.clone()).await, "key", Some(7));
|
||||
let id = paid(&db, None).await;
|
||||
// Billingo makes the invoice, but its answer is lost.
|
||||
assert_eq!(run_once(&db, &billingo, 5).await.unwrap(), 0);
|
||||
assert_eq!(state(&db, id).await.2, None);
|
||||
// The retry finds it instead of making another.
|
||||
sqlx::query("UPDATE invoices SET next_attempt_at = now()").execute(&db).await.unwrap();
|
||||
assert_eq!(run_once(&db, &billingo, 5).await.unwrap(), 1);
|
||||
let (status, number, document, sent, _) = state(&db, id).await;
|
||||
assert_eq!(
|
||||
(status.as_str(), number.as_deref(), document, sent),
|
||||
("issued", Some("SF-2026-1"), Some(901), true)
|
||||
);
|
||||
assert_eq!(fake.documents.load(Ordering::SeqCst), 1);
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn an_invoice_that_cannot_be_emailed_still_counts_as_issued(db: PgPool) {
|
||||
let fake = Arc::new(Fake::default());
|
||||
fake.send_failures.store(100, Ordering::SeqCst);
|
||||
let billingo = Billingo::new(&fake_billingo(fake.clone()).await, "key", Some(7));
|
||||
let id = paid(&db, None).await;
|
||||
run_once(&db, &billingo, 2).await.unwrap();
|
||||
sqlx::query("UPDATE invoices SET next_attempt_at = now()").execute(&db).await.unwrap();
|
||||
assert_eq!(run_once(&db, &billingo, 2).await.unwrap(), 1);
|
||||
let (status, number, _, sent, _) = state(&db, id).await;
|
||||
assert_eq!((status.as_str(), number.as_deref(), sent), ("issued", Some("SF-2026-1"), false));
|
||||
let (error,): (String,) =
|
||||
sqlx::query_as("SELECT last_error FROM invoices WHERE id = $1").bind(id).fetch_one(&db).await.unwrap();
|
||||
assert!(error.starts_with("issued, not e-mailed"), "{error}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -84,12 +84,12 @@ async fn main() -> anyhow::Result<()> {
|
||||
match std::env::args().nth(1).as_deref() {
|
||||
Some("healthcheck") => return service_kit::healthcheck(addr),
|
||||
Some("compare-models") => {
|
||||
service_kit::init_logging();
|
||||
service_kit::init_console_logging();
|
||||
return compare::main(std::env::args().skip(2).collect()).await;
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
service_kit::init_logging();
|
||||
let _log = service_kit::init_logging("worker");
|
||||
let config = Config::from_env()?;
|
||||
let pool = db::connect(&config.database_url).await.context("connecting to the database")?;
|
||||
db::migrate(&pool).await.context("running database migrations")?;
|
||||
@@ -125,7 +125,12 @@ async fn main() -> anyhow::Result<()> {
|
||||
} else {
|
||||
let analyzer = analysis::Analyzer::new(pool.clone(), llm, config.max_analysis_attempts, lanes);
|
||||
tracing::info!(quick = lanes.quick, slow = lanes.slow, "analyses enabled");
|
||||
jobs.spawn(analysis::run(Arc::new(analyzer), config.poll_interval, stop.clone()));
|
||||
jobs.spawn(analysis::run(
|
||||
Arc::new(analyzer),
|
||||
config.poll_interval,
|
||||
config.shutdown_drain,
|
||||
stop.clone(),
|
||||
));
|
||||
}
|
||||
}
|
||||
None => tracing::warn!("OPENROUTER_API_KEY is not set: analyses stay pending"),
|
||||
@@ -158,10 +163,16 @@ async fn main() -> anyhow::Result<()> {
|
||||
() = service_kit::shutdown_signal() => {}
|
||||
}
|
||||
let _ = stop_tx.send(true);
|
||||
// Let jobs finish the batch they are working on.
|
||||
let finished = tokio::time::timeout(Duration::from_secs(30), async { while jobs.join_next().await.is_some() {} });
|
||||
// Nothing new is taken; running work finishes (analyses hand back what is
|
||||
// not done within the drain time, a few seconds before this gives up).
|
||||
tracing::info!(drain_secs = config.shutdown_drain.as_secs(), "stopping: letting running work finish");
|
||||
let finished = tokio::time::timeout(config.shutdown_drain + Duration::from_secs(5), async {
|
||||
while jobs.join_next().await.is_some() {}
|
||||
});
|
||||
if finished.await.is_err() {
|
||||
tracing::warn!("jobs did not stop in time");
|
||||
} else {
|
||||
tracing::info!("all work finished");
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -928,6 +928,49 @@ mod analyses {
|
||||
assert!(!user.contains("Szeged") && !user.contains("Pécs"));
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn a_stop_lets_running_analyses_finish(db: PgPool) {
|
||||
let s = setup(&db).await;
|
||||
let id = request_analysis(&db, &s).await;
|
||||
// A model that takes a while to answer.
|
||||
let body = reply(&content(Kind::Natal)).1;
|
||||
let app = axum::Router::new().route(
|
||||
"/chat/completions",
|
||||
axum::routing::post(move || {
|
||||
let body = body.clone();
|
||||
async move {
|
||||
tokio::time::sleep(std::time::Duration::from_millis(1500)).await;
|
||||
Json(body)
|
||||
}
|
||||
}),
|
||||
);
|
||||
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
|
||||
let url = format!("http://{}", listener.local_addr().unwrap());
|
||||
tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
|
||||
let a = std::sync::Arc::new(analyzer(&db, &url));
|
||||
let (stop_tx, stop) = tokio::sync::watch::channel(false);
|
||||
let drain = std::time::Duration::from_secs(10);
|
||||
let run = tokio::spawn(crate::analysis::run(a, std::time::Duration::from_secs(30), drain, stop));
|
||||
let status = || async {
|
||||
sqlx::query_scalar::<_, String>("SELECT status FROM analyses WHERE id = $1")
|
||||
.bind(id)
|
||||
.fetch_one(&db)
|
||||
.await
|
||||
.unwrap()
|
||||
};
|
||||
for _ in 0..60 {
|
||||
if status().await == "running" {
|
||||
break;
|
||||
}
|
||||
tokio::time::sleep(std::time::Duration::from_millis(50)).await;
|
||||
}
|
||||
assert_eq!(status().await, "running");
|
||||
// A deploy stops the worker while the model is still writing.
|
||||
stop_tx.send(true).unwrap();
|
||||
run.await.unwrap();
|
||||
assert_eq!(status().await, "done");
|
||||
}
|
||||
|
||||
#[sqlx::test(migrator = "db::MIGRATOR")]
|
||||
async fn tarot_readings_are_written_in_the_quick_lane_and_refunded_on_failure(db: PgPool) {
|
||||
let s = setup(&db).await;
|
||||
|
||||
Reference in New Issue
Block a user