diff --git a/.gitea/workflows/ci.yml b/.gitea/workflows/ci.yml index 9c976db..40da6f7 100644 --- a/.gitea/workflows/ci.yml +++ b/.gitea/workflows/ci.yml @@ -59,7 +59,7 @@ jobs: # astro-engine and horoscope-api need the Swiss Ephemeris sources and # data (scripts/fetch-deps.sh); their tests run locally. - name: Test - run: cargo test --locked -p backend -p worker -p db -p horoscope-client -p service-kit + run: cargo test --locked -p backend -p worker -p db -p horoscope-client -p service-kit -p analysis-prompt build: needs: test diff --git a/Cargo.lock b/Cargo.lock index db51107..b25cdf5 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -17,6 +17,13 @@ version = "0.2.21" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923" +[[package]] +name = "analysis-prompt" +version = "0.1.0" +dependencies = [ + "serde_json", +] + [[package]] name = "anyhow" version = "1.0.104" @@ -156,6 +163,7 @@ dependencies = [ name = "backend" version = "0.1.0" dependencies = [ + "analysis-prompt", "anyhow", "argon2", "axum", @@ -2856,6 +2864,7 @@ checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e" name = "worker" version = "0.1.0" dependencies = [ + "analysis-prompt", "anyhow", "axum", "db", diff --git a/Cargo.toml b/Cargo.toml index eca0d9f..3d53720 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -7,6 +7,7 @@ members = [ "crates/service-kit", "crates/db", "crates/horoscope-client", + "crates/analysis-prompt", "services/horoscope-api", "services/backend", "services/worker", @@ -25,6 +26,7 @@ geo-tz = { path = "crates/geo-tz" } service-kit = { path = "crates/service-kit" } db = { path = "crates/db" } horoscope-client = { path = "crates/horoscope-client" } +analysis-prompt = { path = "crates/analysis-prompt" } anyhow = "1" argon2 = { version = "0.5", features = ["std"] } diff --git a/crates/analysis-prompt/Cargo.toml b/crates/analysis-prompt/Cargo.toml new file mode 100644 index 0000000..8126c3f --- /dev/null +++ b/crates/analysis-prompt/Cargo.toml @@ -0,0 +1,10 @@ +[package] +name = "analysis-prompt" +description = "Prompts and answer schemas of the Sorsfonalak LLM analyses (shared by backend and worker)" +edition.workspace = true +version.workspace = true +license.workspace = true +publish.workspace = true + +[dependencies] +serde_json.workspace = true diff --git a/crates/analysis-prompt/src/lib.rs b/crates/analysis-prompt/src/lib.rs new file mode 100644 index 0000000..4cbc483 --- /dev/null +++ b/crates/analysis-prompt/src/lib.rs @@ -0,0 +1,383 @@ +//! Prompts and output schemas of the analyses (prompt version [`PROMPT_VERSION`]). +//! +//! The model answers with one JSON object (OpenRouter structured output); +//! [`validate`] checks it against the same schema before it is stored. +//! +//! The system prompt ([`default_system`]) can be replaced by an admin-edited +//! text; the user message (chart data, section list) and the schema stay fixed. + +use serde_json::{Value, json}; + +/// Matches the backend's `ANALYSIS_PROMPT_VERSION` (part of the cache key). +pub const PROMPT_VERSION: &str = "v2"; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Kind { + Natal, + Synastry, + /// A free teaser of a natal chart: a title and a few sentences. + Summary, +} + +impl Kind { + pub const ALL: [Kind; 3] = [Kind::Summary, Kind::Natal, Kind::Synastry]; + + pub fn as_str(self) -> &'static str { + match self { + Kind::Natal => "natal", + Kind::Synastry => "synastry", + Kind::Summary => "summary", + } + } + + pub fn parse(s: &str) -> Option { + match s { + "natal" => Some(Kind::Natal), + "synastry" => Some(Kind::Synastry), + "summary" => Some(Kind::Summary), + _ => None, + } + } +} + +pub struct Prompt { + pub system: String, + pub user: String, + pub schema_name: &'static str, + pub schema: Value, +} + +/// (key, what the section covers) in reading order. +const NATAL_SECTIONS: [(&str, &str); 6] = [ + ("personality", "Core identity: the Sun, Moon, Ascendant and chart ruler read together"), + ("emotions", "Emotional needs, security and inner life (Moon, 4th house, water emphasis)"), + ("mind", "Thinking, communication and learning (Mercury, 3rd and 9th houses)"), + ("love", "Love, attraction and relationships (Venus, Mars, 5th and 7th houses, Descendant)"), + ("work", "Calling, career, money and daily work (MC, 10th, 2nd and 6th houses, Saturn, Jupiter)"), + ( + "growth", + "Main inner tensions, life lessons and the path of growth (tight squares and oppositions, Saturn, Chiron, Nodes)", + ), +]; + +const SYNASTRY_SECTIONS: [(&str, &str); 5] = [ + ("attraction", "What draws them together: Sun, Moon, Venus, Mars and Ascendant contacts"), + ("communication", "How they think and talk together (Mercury contacts, air emphasis, 3rd house overlays)"), + ("emotional_bond", "Emotional closeness, safety and care (Moon contacts, 4th and 8th house overlays)"), + ("friction", "Where they rub against each other and how to handle it (challenging aspects, Saturn, Pluto, Mars)"), + ("long_term", "Long-term potential and shared purpose, including the composite chart"), +]; + +fn sections(kind: Kind) -> &'static [(&'static str, &'static str)] { + match kind { + Kind::Natal => &NATAL_SECTIONS, + Kind::Synastry => &SYNASTRY_SECTIONS, + Kind::Summary => &[], + } +} + +/// The JSON schema of the answer (strict mode: every property required). +pub fn schema(kind: Kind) -> Value { + if kind == Kind::Summary { + return json!({ + "type": "object", + "additionalProperties": false, + "required": ["title", "summary"], + "properties": { + "title": {"type": "string", "description": "Short, evocative title for this chart (at most 6 words)"}, + "summary": {"type": "string", "description": "3-4 sentences, 60-100 words, one paragraph"} + } + }); + } + let mut props = serde_json::Map::new(); + for (key, about) in sections(kind) { + props.insert( + (*key).into(), + json!({ + "type": "object", + "description": about, + "additionalProperties": false, + "required": ["title", "body"], + "properties": { + "title": {"type": "string", "description": "Short, specific section title (not just the topic name)"}, + "body": {"type": "string", "description": "2-4 paragraphs separated by a blank line"} + } + }), + ); + } + let keys: Vec<&str> = sections(kind).iter().map(|(k, _)| *k).collect(); + json!({ + "type": "object", + "additionalProperties": false, + "required": ["title", "summary", "sections", "strengths", "challenges", "advice"], + "properties": { + "title": {"type": "string", "description": "Short, evocative title for this analysis (at most 8 words)"}, + "summary": {"type": "string", "description": "3-4 sentence overview"}, + "sections": {"type": "object", "additionalProperties": false, "required": keys, "properties": props}, + "strengths": {"type": "array", "items": {"type": "string"}, "description": "3-5 key strengths, one sentence each"}, + "challenges": {"type": "array", "items": {"type": "string"}, "description": "3-5 key challenges, one sentence each"}, + "advice": {"type": "string", "description": "A closing, encouraging paragraph with concrete guidance"} + } + }) +} + +const HUNGARIAN_STYLE: &str = "\ +Write natural, idiomatic Hungarian, as a native Hungarian author would; it must not read like a translation from English. \ +Use correct Hungarian suffixes and vowel harmony, Hungarian quotation marks („…”) and the en dash (–). \ +Use the usual Hungarian astrological terms: +- signs: Kos, Bika, Ikrek, Rák, Oroszlán, Szűz, Mérleg, Skorpió, Nyilas, Bak, Vízöntő, Halak (\"a Nap a Rák jegyében\", \"Kos Aszcendens\"); +- planets and points: Nap, Hold, Merkúr, Vénusz, Mars, Jupiter, Szaturnusz, Uránusz, Neptunusz, Plútó, Chiron (Kiron), \ +Észak-Holdcsomópont, Dél-Holdcsomópont, Lilith (Fekete Hold), Aszcendens, Descendens, Medium Coeli (MC), Imum Coeli (IC), Szerencsepont; +- aspects: együttállás (konjunkció), szextil, kvadrát (négyzet), trigon, szembenállás (oppozíció); +- elements and modalities: tűz, föld, levegő, víz (\"tűz elem\", \"a föld hiánya\"); kardinális, fix, változó; +Never leave English words (e.g. fire, earth, air, water) in the Hungarian text. +- other: \"a 3. házban\", \"a horoszkóp uralkodója\", retrográd, uralom (domicilium), száműzetés, exaltáció, esés, nappali/éjszakai horoszkóp."; + +fn language_name(language: &str) -> &'static str { + match language { + "hu" => "Hungarian", + _ => "English", + } +} + +/// The built-in system prompt of an analysis kind in a language. +pub fn default_system(kind: Kind, language: &str) -> String { + let (role, reader) = match kind { + Kind::Natal => ( + "a personal natal chart interpretation", + "Speak to the owner of the chart directly, in the informal second person singular (in Hungarian: tegező forma, \"te\").", + ), + Kind::Summary => ( + "a short free summary of a natal chart (a teaser shown before the detailed, paid analysis)", + "Speak to the owner of the chart directly, in the informal second person singular (in Hungarian: tegező forma, \"te\").", + ), + Kind::Synastry => ( + "a relationship (synastry) interpretation for two people", + "Write for both people at once, in the informal second person plural (in Hungarian: \"ti\", \"kettőtök\"). \ + When you must tell them apart, call them Person 1 and Person 2 (in Hungarian: \"az első fél\" and \"a második fél\"). \ + Do not assume their genders or the type of relationship.", + ), + }; + let mut text = format!( + "You are an experienced, warm and psychologically minded astrologer. You write {role} for the Sorsfonalak app. + +Write in {lang}. + +Rules: +- Base every statement on the chart data given. Never invent positions, aspects or houses that are not listed. +- When you interpret a placement, name its astrological basis in a short clause, but keep the focus on the person, not on jargon. +- Synthesize: weave signs, houses, aspects and rulers into one coherent portrait; show how tensions can be integrated. \ +Give the most weight to the Sun, Moon, Ascendant, chart ruler, tight aspects (orb under 3°) and strong emphases or gaps in elements and modalities. +- If a birth time is unknown, do not mention houses, the Ascendant or the Midheaven for that chart, and be careful with the Moon's sign. +- {reader} +- Tone: warm, honest, empowering and concrete. Not fatalistic: no predictions of illness, death, accidents or specific events, \ +and no medical, legal or financial advice. +- Avoid generic horoscope clichés and filler: every paragraph must say something specific to this chart. +- Texts are plain paragraphs separated by a blank line, without headings or lists inside; **bold** may be used sparingly. +- {length} +- Answer with a single JSON object that matches the given schema, and nothing else.", + lang = language_name(language), + length = match kind { + Kind::Summary => "Length: one paragraph of 3-4 sentences (60-100 words). Pick the Sun, Moon and Ascendant \ + (if the birth time is known) and the single most striking feature of the chart (a very tight aspect, \ + a stellium, a strong element emphasis or gap). It must be complete in itself and specific to this chart: \ + no sales talk, and do not mention a longer analysis.", + _ => "Length: each section 2-4 paragraphs (about 150-250 words); the whole analysis about 1300-1800 words.", + }, + ); + if language == "hu" { + text.push_str("\n\n"); + text.push_str(HUNGARIAN_STYLE); + } + text +} + +/// Splits a stored prompt version (`v2` or `v2-r`, the id of an admin-edited +/// system prompt in `prompt_revisions`) into the code version and the revision id. +pub fn split_version(version: &str) -> (&str, Option) { + match version.rsplit_once("-r") { + Some((base, id)) => match id.parse() { + Ok(id) => (base, Some(id)), + Err(_) => (version, None), + }, + None => (version, None), + } +} + +/// The built-in text of the user message around the chart data, for showing +/// next to the editable system prompt (`{chart data}` stands for the data). +pub fn user_template(kind: Kind) -> String { + build(kind, "hu", "{chart data}\n", None).user +} + +/// The prompt for one analysis; `system` replaces [`default_system`]. +pub fn build(kind: Kind, language: &str, chart_text: &str, system: Option<&str>) -> Prompt { + let mut user = String::from("Chart data:\n\n"); + user.push_str(chart_text); + if kind == Kind::Summary { + user.push_str("\nWrite the short summary now."); + } else { + user.push_str("\nSections to write, in this order:\n"); + for (key, about) in sections(kind) { + user.push_str(&format!("- {key}: {about}\n")); + } + user.push_str("\nWrite the analysis now."); + } + Prompt { + system: system.map_or_else(|| default_system(kind, language), str::to_owned), + user, + schema_name: match kind { + Kind::Natal => "natal_analysis", + Kind::Synastry => "synastry_analysis", + Kind::Summary => "chart_summary", + }, + schema: schema(kind), + } +} + +/// Checks an answer against our schema subset (objects with required +/// properties, strings with at least three letters, string arrays with at +/// least two items). A placeholder such as "x" counts as missing. +pub fn validate(schema: &Value, value: &Value) -> Result<(), String> { + fn walk(schema: &Value, value: &Value, path: &str) -> Result<(), String> { + match schema["type"].as_str() { + Some("object") => { + let obj = value.as_object().ok_or_else(|| format!("{path}: expected an object"))?; + for key in schema["required"].as_array().into_iter().flatten().filter_map(Value::as_str) { + let child = obj.get(key).ok_or_else(|| format!("{path}.{key}: missing"))?; + walk(&schema["properties"][key], child, &format!("{path}.{key}"))?; + } + Ok(()) + } + Some("array") => { + let items = value.as_array().ok_or_else(|| format!("{path}: expected an array"))?; + if items.len() < 2 { + return Err(format!("{path}: too few items")); + } + items.iter().enumerate().try_for_each(|(i, v)| walk(&schema["items"], v, &format!("{path}[{i}]"))) + } + Some("string") => match value.as_str() { + Some(s) if s.chars().filter(|c| c.is_alphabetic()).nth(2).is_some() => Ok(()), + _ => Err(format!("{path}: expected a non-empty string")), + }, + _ => Ok(()), + } + } + walk(schema, value, "$") +} + +/// Fixes typography the models often get wrong. In Hungarian, pairs of +/// straight double quotes become „…” (only when they pair up evenly). +pub fn polish(language: &str, content: &mut Value) { + fn hungarian_quotes(text: &str) -> Option { + if !text.contains('"') || !text.matches('"').count().is_multiple_of(2) { + return None; + } + let mut open = true; + Some( + text.chars() + .map(|c| match c { + '"' => { + let q = if open { '„' } else { '”' }; + open = !open; + q + } + c => c, + }) + .collect(), + ) + } + match content { + Value::String(s) if language == "hu" => { + if let Some(fixed) = hungarian_quotes(s) { + *s = fixed; + } + } + Value::Array(items) => items.iter_mut().for_each(|v| polish(language, v)), + Value::Object(map) => map.values_mut().for_each(|v| polish(language, v)), + _ => {} + } +} + +/// The analysis as Markdown (for reading and comparing outputs). +pub fn to_markdown(kind: Kind, language: &str, content: &Value) -> String { + let (strengths, challenges, advice) = if language == "hu" { + ("Erősségek", "Kihívások", "Útravaló") + } else { + ("Strengths", "Challenges", "Advice") + }; + let mut md = + format!("# {}\n\n_{}_\n\n", content["title"].as_str().unwrap_or(""), content["summary"].as_str().unwrap_or("")); + if kind == Kind::Summary { + return md; + } + for (key, _) in sections(kind) { + let s = &content["sections"][*key]; + md.push_str(&format!("## {}\n\n{}\n\n", s["title"].as_str().unwrap_or(key), s["body"].as_str().unwrap_or(""))); + } + for (title, key) in [(strengths, "strengths"), (challenges, "challenges")] { + md.push_str(&format!("## {title}\n\n")); + for item in content[key].as_array().into_iter().flatten().filter_map(Value::as_str) { + md.push_str(&format!("- {item}\n")); + } + md.push('\n'); + } + md.push_str(&format!("## {advice}\n\n{}\n", content["advice"].as_str().unwrap_or(""))); + md +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn summary_prompt_is_short() { + let p = build(Kind::Summary, "hu", "SUN: Cancer", None); + assert_eq!(p.schema_name, "chart_summary"); + assert!(p.system.contains("3-4 sentences") && p.system.contains("tegező")); + assert!(!p.user.contains("Sections to write")); + assert_eq!(validate(&p.schema, &json!({"title": "Érzékeny mag", "summary": "Rövid szöveg."})), Ok(())); + assert!(validate(&p.schema, &json!({"title": "Érzékeny mag"})).is_err()); + let md = to_markdown(Kind::Summary, "hu", &json!({"title": "Cím", "summary": "Szöveg."})); + assert_eq!(md, "# Cím\n\n_Szöveg._\n\n"); + } + + #[test] + fn custom_system_replaces_only_the_rules() { + let p = build(Kind::Natal, "hu", "SUN: Cancer", Some("Saját szabályok.")); + assert_eq!(p.system, "Saját szabályok."); + assert!(p.user.contains("SUN: Cancer") && p.user.contains("- personality:")); + assert_eq!(p.schema, schema(Kind::Natal)); + assert!(user_template(Kind::Natal).contains("{chart data}")); + assert_eq!(split_version("v2-r12"), ("v2", Some(12))); + assert_eq!(split_version("v2"), ("v2", None)); + assert!(Kind::ALL.iter().all(|k| Kind::parse(k.as_str()) == Some(*k))); + } + + #[test] + fn validate_rejects_placeholder_titles() { + let schema = schema(Kind::Synastry); + let section = json!({"title": "Rák-szívek", "body": "Két bekezdés szöveg."}); + let mut answer = json!({ + "title": "Két Rák-szív", "summary": "Összefoglaló.", "advice": "Útravaló.", + "strengths": ["Egyik erősség.", "Másik erősség."], "challenges": ["Egy kihívás.", "Még egy."], + "sections": {"attraction": section, "communication": section, "emotional_bond": section, + "friction": section, "long_term": section}, + }); + assert_eq!(validate(&schema, &answer), Ok(())); + answer["sections"]["attraction"]["title"] = json!("x"); + assert_eq!(validate(&schema, &answer), Err("$.sections.attraction.title: expected a non-empty string".into())); + } + + #[test] + fn polish_turns_straight_quotes_hungarian() { + let mut v = json!({"a": "a \"hazai pálya\" és a \"sorok\"", "b": ["egy \" pár nélkül"], "c": {"d": "nincs"}}); + polish("hu", &mut v); + assert_eq!(v["a"], "a „hazai pálya” és a „sorok”"); + assert_eq!(v["b"][0], "egy \" pár nélkül"); + assert_eq!(v["c"]["d"], "nincs"); + let mut en = json!({"a": "the \"home\" ground"}); + polish("en", &mut en); + assert_eq!(en["a"], "the \"home\" ground"); + } +} diff --git a/crates/db/migrations/0009_prompt_revisions.sql b/crates/db/migrations/0009_prompt_revisions.sql new file mode 100644 index 0000000..d0505fe --- /dev/null +++ b/crates/db/migrations/0009_prompt_revisions.sql @@ -0,0 +1,14 @@ +-- Admin-edited system prompts of the analyses. The newest row of a +-- (kind, language) is in force; system NULL means the built-in default. +-- An analysis records the revision it was written with in prompt_version +-- ("v2-r"), so the worker uses exactly that text. +CREATE TABLE prompt_revisions ( + id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY, + kind text NOT NULL CHECK (kind IN ('summary', 'natal', 'synastry')), + language text NOT NULL, + system text CHECK (system IS NULL OR length(system) BETWEEN 1 AND 50000), + created_by uuid REFERENCES users ON DELETE SET NULL, + created_at timestamptz NOT NULL DEFAULT now() +); + +CREATE INDEX prompt_revisions_current ON prompt_revisions (kind, language, id DESC); diff --git a/crates/db/migrations/0010_prompt_previews.sql b/crates/db/migrations/0010_prompt_previews.sql new file mode 100644 index 0000000..d34e02d --- /dev/null +++ b/crates/db/migrations/0010_prompt_previews.sql @@ -0,0 +1,29 @@ +-- Test runs of an edited (not yet saved) system prompt on one of the admin's +-- charts. Kept apart from analyses: never shown to users, never cached, no +-- credits, one attempt. Removed after 30 days by the cleanup job. +CREATE TABLE prompt_previews ( + id uuid PRIMARY KEY, + kind text NOT NULL CHECK (kind IN ('summary', 'natal')), + chart_id uuid NOT NULL REFERENCES charts ON DELETE CASCADE, + language text NOT NULL, + model text NOT NULL, + system text NOT NULL CHECK (length(system) BETWEEN 1 AND 50000), + status text NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'running', 'done', 'failed')), + content jsonb, + error text, + model_used text, + input_tokens integer, + output_tokens integer, + cost_usd double precision, + created_by uuid NOT NULL REFERENCES users ON DELETE CASCADE, + created_at timestamptz NOT NULL DEFAULT now(), + started_at timestamptz, + completed_at timestamptz +); + +CREATE INDEX prompt_previews_pending_idx ON prompt_previews (created_at) WHERE status = 'pending'; + +-- Wakes the analysis worker, like a new analysis. +CREATE TRIGGER prompt_previews_notify + AFTER INSERT ON prompt_previews + FOR EACH STATEMENT EXECUTE FUNCTION notify_analyses(); diff --git a/crates/db/migrations/0011_synastry_previews.sql b/crates/db/migrations/0011_synastry_previews.sql new file mode 100644 index 0000000..93a00ee --- /dev/null +++ b/crates/db/migrations/0011_synastry_previews.sql @@ -0,0 +1,10 @@ +-- Prompt test runs of the relationship (synastry) analysis: on one of the +-- admin's comparisons instead of a chart. +ALTER TABLE prompt_previews DROP CONSTRAINT prompt_previews_kind_check; +ALTER TABLE prompt_previews ALTER COLUMN chart_id DROP NOT NULL; +ALTER TABLE prompt_previews + ADD COLUMN synastry_id uuid REFERENCES synastries ON DELETE CASCADE, + ADD CONSTRAINT prompt_previews_target CHECK ( + (kind IN ('summary', 'natal') AND chart_id IS NOT NULL AND synastry_id IS NULL) + OR (kind = 'synastry' AND synastry_id IS NOT NULL AND chart_id IS NULL) + ); diff --git a/crates/db/migrations/0012_packages.sql b/crates/db/migrations/0012_packages.sql new file mode 100644 index 0000000..cecd653 --- /dev/null +++ b/crates/db/migrations/0012_packages.sql @@ -0,0 +1,26 @@ +-- Packages: every purchase or admin grant of a package is an order; the units +-- it gives are credit_ledger rows pointing at it (reason 'package'), and the +-- unlimited package is a time-limited 'unlimited' entitlement. +CREATE TABLE package_orders ( + id uuid PRIMARY KEY, + user_id uuid NOT NULL REFERENCES users ON DELETE CASCADE, + package text NOT NULL, + source text NOT NULL CHECK (source IN ('admin', 'mock', 'stripe')), + price_huf integer NOT NULL DEFAULT 0 CHECK (price_huf >= 0), + note text, + created_by uuid REFERENCES users ON DELETE SET NULL, + created_at timestamptz NOT NULL DEFAULT now() +); + +CREATE INDEX package_orders_user_idx ON package_orders (user_id, created_at DESC); + +ALTER TABLE credit_ledger DROP CONSTRAINT credit_ledger_reason_check; +ALTER TABLE credit_ledger ADD CONSTRAINT credit_ledger_reason_check + CHECK (reason IN ('monthly_grant', 'analysis', 'chat', 'refund', 'admin_adjust', 'purchase', 'person', 'package')); +ALTER TABLE credit_ledger ADD COLUMN order_id uuid REFERENCES package_orders ON DELETE SET NULL; + +-- 'unlimited': analyses and persons without limit until expires_at. +ALTER TABLE entitlements DROP CONSTRAINT entitlements_entitlement_check; +ALTER TABLE entitlements ADD CONSTRAINT entitlements_entitlement_check + CHECK (entitlement IN ('unlimited_persons', 'unlimited')); +ALTER TABLE entitlements ADD COLUMN expires_at timestamptz; diff --git a/deploy/docker-compose.yml b/deploy/docker-compose.yml index 393d7aa..040a095 100644 --- a/deploy/docker-compose.yml +++ b/deploy/docker-compose.yml @@ -88,7 +88,7 @@ services: # Stand-in payment (adds an analysis unit at once) until Stripe is connected. MOCK_PAYMENTS: ${MOCK_PAYMENTS:-true} FREE_PERSON_SLOTS: ${FREE_PERSON_SLOTS:-0} - PERSON_PACK_SIZE: ${PERSON_PACK_SIZE:-5} + UNLIMITED_DAILY_LIMIT: ${UNLIMITED_DAILY_LIMIT:-5} depends_on: postgres: condition: service_healthy diff --git a/docker-compose.yml b/docker-compose.yml index 3136b2b..fb9d433 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -56,7 +56,7 @@ services: # Stand-in payment (adds an analysis unit at once) until Stripe is connected. MOCK_PAYMENTS: ${MOCK_PAYMENTS:-true} FREE_PERSON_SLOTS: ${FREE_PERSON_SLOTS:-0} - PERSON_PACK_SIZE: ${PERSON_PACK_SIZE:-5} + UNLIMITED_DAILY_LIMIT: ${UNLIMITED_DAILY_LIMIT:-5} depends_on: postgres: condition: service_healthy diff --git a/docs/csomagok.md b/docs/csomagok.md new file mode 100644 index 0000000..ce02437 --- /dev/null +++ b/docs/csomagok.md @@ -0,0 +1,39 @@ +# Csomagok és árazás + +A katalógus a kódban van: `services/backend/src/packages.rs` (`CATALOG`). Ár- vagy tartalomváltozás egy deploy. + +## Költség + +Egy részletes képletelemzés és egy kapcsolati elemzés is kb. **$0,21 (≈ 80 Ft)** Opus 5.5-tel; a rövid összefoglaló kb. $0,01. A fizetési szolgáltató díja kb. 1,5% + 85 Ft tranzakciónként. Az árak bruttók (27% áfa). + +## A lépcső + +| Csomag | Tartalom | Ár | Elemzésenként | Külön megvéve | Megtakarítás | +|---|---|---|---|---|---| +| Egy elemzés | 1 képletelemzés | 2 990 Ft | 2 990 Ft | – | – | +| Páros | 2 képletelemzés, 1 kapcsolati, 1 személy | 6 990 Ft | 2 330 Ft | 9 868 Ft | 29% | +| **Család** (Legnépszerűbb) | 6 képletelemzés, 5 kapcsolati, 5 személy | 11 990 Ft | 1 090 Ft | 37 380 Ft | 68% | +| Korlátlan | minden korlátlanul, 12 hónapig | 17 990 Ft | – | – | – | +| +1 kapcsolati elemzés | kiegészítő | 3 490 Ft | | | | +| +5 személy | kiegészítő | 1 990 Ft | | | | + +## Miért így (a nagyobb felé terelés) + +- **Horgony:** az Egy elemzés ára (2 990 Ft) az egységár. Minden más ehhez mérve látszik olcsónak; a kártyákon áthúzva ott a „külön megvéve” ár. +- **Kis lépések, nagy ugrások:** minden szint csak egy kicsivel drágább az előzőnél, de sokkal többet ad. Páros: +4 000 Ft-ért háromszor annyi elemzés. Család: +5 000 Ft-ért majdnem négyszer annyi. Korlátlan: +6 000 Ft-ért nincs határ. A kártyán ki is írjuk: „Csak +5 000 Ft a Páros csomaghoz képest”. +- **Csali:** a Páros szándékosan „csak jó” ajánlat (−29%), hogy mellette a Család (−68%) kiugorjon. A Család kapja a kiemelést és a „Legnépszerűbb” címkét. +- **A Korlátlan mint felső horgony:** a Család ára mellette mérsékeltnek tűnik; aki sokakat venne fel, annak a 6 000 Ft különbség semmiség. +- **Drága kiegészítők:** a +1 kapcsolati elemzés 3 490 Ft, többe kerül, mint egy képletelemzés, és a Páros már kettő árán ad egyet kettőtök képletével együtt. Aki darabonként venne, annak jobban megéri csomagot venni. +- **A vásárlás pillanatában** (a „Részletes elemzés kérése” után) nem egy darabot kínálunk, hanem három csomagot egymás mellett, kiemelt Családdal. +- **Nem jár le:** a megvett elemzések megmaradnak, ezért a nagyobb csomag nem kockázat a vevőnek. + +## Korlátlan csomag + +Egy év; ha még tart, egy újabb a lejárathoz ad hozzá egy évet. Méltányos használat: naponta legfeljebb `UNLIMITED_DAILY_LIMIT` (alapból 5) új részletes elemzés. Legrosszabb esetben is jóval a csomag ára alatt marad a költség, ha valaki nem visszaélésszerűen használja; a napi korlát a gépi tömeges lekérést fogja meg. + +## Későbbre + +- Stripe-bekötés: a `package_orders.source = 'stripe'` már helyet kapott. +- Bevezető kedvezmény vagy kupon (pl. az első 100 vásárlónak). +- Ajándékba adható csomag (karácsony, Valentin-nap): a Páros és a Család jó ajándék. +- Számlázás (NAV Online Számla) a vásárlásokhoz. diff --git a/services/backend/Cargo.toml b/services/backend/Cargo.toml index c568fa3..4ba6e9f 100644 --- a/services/backend/Cargo.toml +++ b/services/backend/Cargo.toml @@ -8,6 +8,7 @@ publish.workspace = true [dependencies] db.workspace = true +analysis-prompt.workspace = true horoscope-client.workspace = true service-kit.workspace = true anyhow.workspace = true diff --git a/services/backend/README.md b/services/backend/README.md index 30b7363..5970d43 100644 --- a/services/backend/README.md +++ b/services/backend/README.md @@ -14,9 +14,9 @@ Felhasználók, belépés, mentett születési képletek, szinasztriák és megh | `COOKIE_DOMAIN` | – | pl. `.sorsfonalak.hu`, ha a frontend és az API más aldomainen fut | | `SESSION_TTL_DAYS` | `30` | a munkamenet élettartama | | `PASSWORD_LOGIN` | `false` | e-mail + jelszó regisztráció és belépés; élesben ki van kapcsolva (csak Google, Apple, Facebook), a jelszavas végpontok ilyenkor 403-at adnak | -| `MOCK_PAYMENTS` | `false` | próbafizetés a Stripe bekötéséig: a `POST /v1/payments/mock` azonnal jóváír egy elemzési egységet (`{"unit": "natal"}`) vagy személycsomagot (`{"package": "persons"}` / `"persons_unlimited"`); a compose-fájlokban egyelőre `true` | +| `MOCK_PAYMENTS` | `false` | próbafizetés a Stripe bekötéséig: a `POST /v1/payments/mock` `{"package": ""}` azonnal jóváírja a katalógus egy csomagját (`{"unit": "natal"}` rövidítés: a legkisebb ilyen csomag); a compose-fájlokban egyelőre `true` | | `FREE_PERSON_SLOTS` | `0` | ennyi személyt vehet fel csomag nélkül egy felhasználó | -| `PERSON_PACK_SIZE` | `5` | ennyi személy van egy személycsomagban | +| `UNLIMITED_DAILY_LIMIT` | `5` | a Korlátlan csomaggal naponta ennyi új részletes elemzés kérhető (méltányos használat; utána 429 `fair_use_limit`) | | `GOOGLE_CLIENT_IDS` | – | Google OAuth kliens-azonosító(k); üresen a Google-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 | @@ -48,6 +48,7 @@ Felhasználók, belépés, mentett születési képletek, szinasztriák és megh | Végpont | Guard | Leírás | |---|---|---| | `GET /v1/config` | – | Google kliens-azonosító, `password_login`, nyelvek, elemző és összefoglaló modell | +| `GET /v1/packages` | – | a csomagkatalógus árral, tartalommal, megtakarítással, elemzésenkénti árral (lásd `docs/csomagok.md`) | | `POST /v1/auth/register` | – | `{email, password, display_name?, locale?}` → munkamenet; megerősítő e-mailt küld | | `POST /v1/auth/login` | – | `{email, password}` | | `POST /v1/auth/google` | – | `{id_token}`; `created: true`, ha most jött létre a fiók | @@ -76,7 +77,12 @@ Felhasználók, belépés, mentett születési képletek, szinasztriák és megh | `GET /v1/public/shares/{slug}` | – | a megosztott tartalom (oldal + OG-kép adatai) | | `GET /v1/admin/users?q=` | admin | felhasználók kereséssel, szerepekkel, megmaradt elemzésekkel | | `PATCH /v1/admin/users/{id}` | admin | `{roles: [...]}`; a saját admin szerep nem vehető el | +| `POST /v1/admin/users/{id}/packages` | admin | `{package, note?}`: csomag kiosztása ajándékként (`package_orders`, ár 0) | | `POST /v1/admin/users/{id}/credits` | admin | `{unit: natal\|synastry, delta, note?}`: elemzések jóváírása vagy levonása | +| `GET /v1/admin/prompts` | admin | a tömör és a részletes elemzés system promptja nyelvenként: érvényes szöveg, alapértelmezett, változatok | +| `PUT /v1/admin/prompts/{kind}/{language}` | admin | `{system}` új változatként menti (`null` vagy az alapértelmezett szöveg: vissza a beépítettre); az új elemzések `prompt_version`-je `v2-r` | +| `POST /v1/admin/prompts/{kind}/{language}/preview` | admin | `{system, chart_id}`: próbafuttatás a (mentetlen) szöveggel egy saját képleten; nem kerül a képlethez, nem gyorsítótárazott, nem fogy egység; egyszerre legfeljebb 3 | +| `GET /v1/admin/previews/{id}` | admin | a próbafuttatás állapota és eredménye (modell, token, költség) | Hibák formátuma: `{"error": {"code", "message"}}`. A születési adatok hibái (például ismeretlen hely, javaslatokkal együtt) változatlanul jönnek tovább a horoscope-api-ból. @@ -118,5 +124,5 @@ A [worker](../worker/README.md) kiküldi az e-maileket, megírja az elemzéseket ## Korlátok - **Saját születési adatok módosítása:** az első mentés után egy órán belül még háromszor javíthatók, utána naponta egyszer (`birth_data_changes` tábla). A tiltott módosítás 429-et ad `birth_data_change_limit` kóddal, a felhasználónak szóló üzenettel („A rendszer csak napi egy módosítást engedélyez. …”). A `/v1/me` `birth_change` mezője mutatja, él-e a napi korlát. Más emberek képleteit ez nem érinti. -- **Személyek** (más emberek képletei, `charts.kind = 'person'`): minden új személy egy `person` egységet használ (`credit_ledger`, `reason = 'person'`); a törlés nem adja vissza. Egységet a személycsomag ad (`PERSON_PACK_SIZE` darab), a korlátlan csomag az `entitlements` tábla `unlimited_persons` sora. Ha elfogyott, 409 `person_limit_reached`. Egy személy születési adatai a felvétel után egy órán belül javíthatók (`PATCH /v1/charts/{id}` `birth` mezővel), utána 409 `person_locked`; részletes elemzés vagy szinasztria után sem. A `/v1/me` `persons` mezője: `used`, `limit`, `left`, `unlimited`. +- **Személyek** (más emberek képletei, `charts.kind = 'person'`): minden új személy egy `person` egységet használ (`credit_ledger`, `reason = 'person'`); a törlés nem adja vissza. Helyet a csomagok adnak; korlátlan az `unlimited_persons` jogosultsággal és futó Korlátlan csomaggal. Ha elfogyott, 409 `person_limit_reached`. Egy személy születési adatai a felvétel után egy órán belül javíthatók (`PATCH /v1/charts/{id}` `birth` mezővel), utána 409 `person_locked`. Részletes elemzés (képlet vagy összevetés) után sem (409 `person_analysed`), és akkor sem, ha valaki más összevetésében szerepel (409 `person_in_synastry`); a saját, elemzés nélküli összevetései a javításkor törlődnek. A `/v1/me` `persons` mezője: `used`, `limit`, `left`, `unlimited`. - **Admin:** nincs módosítási korlát, korlátlan személy, a személyek adatai bármikor javíthatók, és a részletes elemzés ingyenes (nem fogy egység). diff --git a/services/backend/src/config.rs b/services/backend/src/config.rs index 96536ea..12211c7 100644 --- a/services/backend/src/config.rs +++ b/services/backend/src/config.rs @@ -49,8 +49,8 @@ pub struct Config { pub max_charts_per_user: i64, /// `FREE_PERSON_SLOTS` (default 0): persons a user may add without a package. pub free_person_slots: i64, - /// `PERSON_PACK_SIZE` (default 5): persons in one person package. - pub person_pack_size: i64, + /// `UNLIMITED_DAILY_LIMIT` (default 5): new detailed analyses a day with the unlimited package. + pub unlimited_daily_limit: i64, } fn var(name: &str) -> Option { @@ -105,7 +105,7 @@ impl Config { prompt_version: var("ANALYSIS_PROMPT_VERSION").unwrap_or_else(|| "v2".into()), max_charts_per_user: parsed("MAX_CHARTS_PER_USER", 1000)?, free_person_slots: parsed("FREE_PERSON_SLOTS", 0)?, - person_pack_size: parsed("PERSON_PACK_SIZE", 5)?, + unlimited_daily_limit: parsed("UNLIMITED_DAILY_LIMIT", 5)?, }; if config.session_ttl_days < 1 { bail!("SESSION_TTL_DAYS must be at least 1"); @@ -135,7 +135,7 @@ impl Config { prompt_version: "v1".into(), max_charts_per_user: 50, free_person_slots: 5, - person_pack_size: 5, + unlimited_daily_limit: 3, } } } diff --git a/services/backend/src/main.rs b/services/backend/src/main.rs index dc2f9ec..8f45927 100644 --- a/services/backend/src/main.rs +++ b/services/backend/src/main.rs @@ -13,6 +13,7 @@ mod config; mod credits; mod error; mod google; +mod packages; mod persons; mod routes; #[cfg(test)] diff --git a/services/backend/src/packages.rs b/services/backend/src/packages.rs new file mode 100644 index 0000000..9d6ffe2 --- /dev/null +++ b/services/backend/src/packages.rs @@ -0,0 +1,285 @@ +//! Packages: what a user can buy (or an admin can give). The catalog is +//! fixed here; see `docs/csomagok.md` for the reasoning behind it. +//! +//! A package gives analysis units and person slots (`credit_ledger` rows +//! with reason `package`) that never expire, or a time-limited `unlimited` +//! entitlement: analyses and persons without limit, with a daily fair-use cap. + +use serde_json::{Value, json}; +use sqlx::PgConnection; +use time::OffsetDateTime; +use uuid::Uuid; + +use crate::credits::Unit; +use crate::error::ApiError; + +/// List prices of the single items, for showing what a package saves. +const NATAL_PRICE: i64 = 2_990; +const SYNASTRY_PRICE: i64 = 3_490; +const PERSON_PRICE: i64 = 398; // 1 990 Ft for five + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Tier { + /// The main ladder, shown side by side. + Main, + /// Top-ups for those who already have something. + Addon, +} + +#[derive(Debug, Clone, Copy)] +pub struct Package { + pub id: &'static str, + pub name: &'static str, + pub tagline: &'static str, + pub tier: Tier, + /// Gross price (27% VAT included). + pub price_huf: i64, + pub natal: i64, + pub synastry: i64, + pub persons: i64, + /// Months of unlimited analyses and persons. + pub unlimited_months: Option, + /// Badge on the card ("Legnépszerűbb"). + pub badge: Option<&'static str>, +} + +pub const CATALOG: [Package; 6] = [ + Package { + id: "single", + name: "Egy elemzés", + tagline: "Egy részletes képletelemzés: neked vagy egy felvett személynek.", + tier: Tier::Main, + price_huf: 2_990, + natal: 1, + synastry: 0, + persons: 0, + unlimited_months: None, + badge: None, + }, + Package { + id: "couple", + name: "Páros", + tagline: "Te és ő: mindkettőtök képlete és a kapcsolati elemzés.", + tier: Tier::Main, + price_huf: 6_990, + natal: 2, + synastry: 1, + persons: 1, + unlimited_months: None, + badge: None, + }, + Package { + id: "family", + name: "Család", + tagline: "Az egész család: öt személy, mindenki képlete, és öt kapcsolat.", + tier: Tier::Main, + price_huf: 11_990, + natal: 6, + synastry: 5, + persons: 5, + unlimited_months: None, + badge: Some("Legnépszerűbb"), + }, + Package { + id: "unlimited", + name: "Korlátlan", + tagline: "Egy évig bárki, bármennyi elemzés és összevetés.", + tier: Tier::Main, + price_huf: 17_990, + natal: 0, + synastry: 0, + persons: 0, + unlimited_months: Some(12), + badge: None, + }, + Package { + id: "addon_synastry", + name: "+1 kapcsolati elemzés", + tagline: "Egy újabb összevetés részletes elemzése.", + tier: Tier::Addon, + price_huf: 3_490, + natal: 0, + synastry: 1, + persons: 0, + unlimited_months: None, + badge: None, + }, + Package { + id: "addon_persons", + name: "+5 személy", + tagline: "Még öt ember képlete (az elemzés külön jár).", + tier: Tier::Addon, + price_huf: 1_990, + natal: 0, + synastry: 0, + persons: 5, + unlimited_months: None, + badge: None, + }, +]; + +pub fn find(id: &str) -> Option<&'static Package> { + CATALOG.iter().find(|p| p.id == id) +} + +impl Package { + /// What the contents would cost one by one (`None` for the unlimited one). + fn list_price(&self) -> Option { + self.unlimited_months + .is_none() + .then(|| self.natal * NATAL_PRICE + self.synastry * SYNASTRY_PRICE + self.persons * PERSON_PRICE) + } + + pub fn view(&self) -> Value { + let analyses = self.natal + self.synastry; + let savings = self + .list_price() + .filter(|&list| list > self.price_huf) + .map(|list| ((list - self.price_huf) * 100 + list / 2) / list); + json!({ + "id": self.id, + "name": self.name, + "tagline": self.tagline, + "tier": match self.tier { Tier::Main => "main", Tier::Addon => "addon" }, + "price_huf": self.price_huf, + "natal": self.natal, + "synastry": self.synastry, + "persons": self.persons, + "unlimited_months": self.unlimited_months, + "badge": self.badge, + "list_price_huf": self.list_price(), + "savings_percent": savings, + "per_analysis_huf": (analyses > 0).then(|| (self.price_huf + analyses / 2) / analyses), + }) + } +} + +/// Who gives the package. +#[derive(Debug, Clone, Copy)] +pub enum Source { + Admin, + Mock, +} + +impl Source { + fn as_str(self) -> &'static str { + match self { + Source::Admin => "admin", + Source::Mock => "mock", + } + } +} + +/// Records an order and gives its contents, inside the caller's transaction. +pub async fn grant( + tx: &mut PgConnection, + user_id: Uuid, + package: &Package, + source: Source, + created_by: Option, + note: Option<&str>, +) -> Result { + let order = Uuid::now_v7(); + let price = match source { + Source::Admin => 0, + Source::Mock => package.price_huf, + }; + sqlx::query( + "INSERT INTO package_orders (id, user_id, package, source, price_huf, note, created_by) \ + VALUES ($1, $2, $3, $4, $5, $6, $7)", + ) + .bind(order) + .bind(user_id) + .bind(package.id) + .bind(source.as_str()) + .bind(price as i32) + .bind(note) + .bind(created_by) + .execute(&mut *tx) + .await?; + for (unit, n) in [(Unit::Natal, package.natal), (Unit::Synastry, package.synastry), (Unit::Person, package.persons)] + { + if n == 0 { + continue; + } + sqlx::query( + "INSERT INTO credit_ledger (id, user_id, unit, delta, reason, order_id, note, created_by) \ + VALUES ($1, $2, $3, $4, 'package', $5, $6, $7)", + ) + .bind(Uuid::now_v7()) + .bind(user_id) + .bind(unit.as_str()) + .bind(n as i32) + .bind(order) + .bind(package.name) + .bind(created_by) + .execute(&mut *tx) + .await?; + } + if let Some(months) = package.unlimited_months { + // Buying again extends from the current end, not from today. + sqlx::query( + "INSERT INTO entitlements (user_id, entitlement, note, created_by, expires_at) \ + VALUES ($1, 'unlimited', $2, $3, now() + make_interval(months => $4)) \ + ON CONFLICT (user_id, entitlement) DO UPDATE SET \ + expires_at = greatest(entitlements.expires_at, now()) + make_interval(months => $4), \ + note = EXCLUDED.note, created_by = EXCLUDED.created_by", + ) + .bind(user_id) + .bind(package.name) + .bind(created_by) + .bind(months as i32) + .execute(&mut *tx) + .await?; + } + Ok(order) +} + +/// Until when the user's unlimited package runs (`None`: none, or it ended). +pub async fn unlimited_until(conn: &mut PgConnection, user_id: Uuid) -> Result, ApiError> { + let until: Option = sqlx::query_scalar( + "SELECT expires_at FROM entitlements \ + WHERE user_id = $1 AND entitlement = 'unlimited' AND expires_at > now()", + ) + .bind(user_id) + .fetch_optional(conn) + .await? + .flatten(); + Ok(until) +} + +/// The fair-use cap of the unlimited package: new detailed analyses in 24 hours. +pub async fn check_fair_use(conn: &mut PgConnection, user_id: Uuid, daily_limit: i64) -> Result<(), ApiError> { + let (count,): (i64,) = sqlx::query_as( + "SELECT count(*) FROM analyses WHERE requested_by = $1 AND kind IN ('natal', 'synastry') \ + AND created_at > now() - interval '24 hours'", + ) + .bind(user_id) + .fetch_one(conn) + .await?; + if count >= daily_limit { + return Err(ApiError::Limited { + code: "fair_use_limit", + message: format!( + "A korlátlan csomaggal naponta legfeljebb {daily_limit} új részletes elemzés kérhető. Holnap folytathatod." + ), + }); + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn bigger_packages_are_cheaper_per_analysis() { + let per = |id: &str| find(id).unwrap().view()["per_analysis_huf"].as_i64().unwrap(); + assert!(per("single") > per("couple") && per("couple") > per("family")); + assert_eq!(find("family").unwrap().view()["savings_percent"], 68); + assert_eq!(find("couple").unwrap().view()["savings_percent"], 29); + assert!(find("single").unwrap().view()["savings_percent"].is_null()); + assert!(find("unlimited").unwrap().view()["list_price_huf"].is_null()); + assert!(CATALOG.iter().all(|p| find(p.id).is_some())); + } +} diff --git a/services/backend/src/persons.rs b/services/backend/src/persons.rs index 5ba6228..b17123a 100644 --- a/services/backend/src/persons.rs +++ b/services/backend/src/persons.rs @@ -1,7 +1,7 @@ //! Persons: charts of other people (name and birth data) a user adds next to //! their own. Each new person uses one `person` unit, bought in packages; -//! deleting a person does not give it back. An unlimited package -//! (`unlimited_persons` entitlement) and admins have no limit. +//! deleting a person does not give it back. The `unlimited_persons` +//! entitlement, a running unlimited package and admins have no limit. //! //! A person's birth data can be corrected within an hour of adding them, //! then it is locked (admins: any time). @@ -53,7 +53,8 @@ pub async fn slots(conn: &mut PgConnection, auth: &AuthUser, free: i64) -> Resul (SELECT COUNT(*) FROM credit_ledger WHERE user_id = $1 AND unit = 'person' AND reason = 'person'), \ (SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger \ WHERE user_id = $1 AND unit = 'person' AND reason <> 'person'), \ - EXISTS (SELECT 1 FROM entitlements WHERE user_id = $1 AND entitlement = 'unlimited_persons')", + EXISTS (SELECT 1 FROM entitlements WHERE user_id = $1 \ + AND (entitlement = 'unlimited_persons' OR (entitlement = 'unlimited' AND expires_at > now())))", ) .bind(auth.id()) .fetch_one(conn) diff --git a/services/backend/src/routes/account.rs b/services/backend/src/routes/account.rs index 286fef8..5f74b32 100644 --- a/services/backend/src/routes/account.rs +++ b/services/backend/src/routes/account.rs @@ -32,6 +32,7 @@ pub async fn me(State(state): St, auth: AuthUser) -> ApiResult> { let balance = credits::balance(&mut conn, auth.id()).await?; let birth_change = crate::birth_changes::view(&mut conn, &auth).await?; let persons = crate::persons::slots(&mut conn, &auth, state.config.free_person_slots).await?; + let unlimited = crate::packages::unlimited_until(&mut conn, auth.id()).await?; Ok(Json(json!({ "user": UserView::from(&auth.user), "providers": providers.into_iter().map(|(p,)| p).collect::>(), @@ -39,6 +40,7 @@ pub async fn me(State(state): St, auth: AuthUser) -> ApiResult> { "analyses_left": balance.view(), "birth_change": birth_change, "persons": persons.view(), + "unlimited_until": rfc3339_opt(unlimited), }))) } diff --git a/services/backend/src/routes/admin.rs b/services/backend/src/routes/admin.rs index e40b16c..0b58450 100644 --- a/services/backend/src/routes/admin.rs +++ b/services/backend/src/routes/admin.rs @@ -14,6 +14,7 @@ use super::{Body, IdPath, St}; use crate::auth::AdminUser; use crate::credits::{self, Unit}; use crate::error::{ApiError, ApiResult}; +use crate::packages::{self, Source}; use crate::views::{rfc3339, rfc3339_opt}; #[derive(Deserialize)] @@ -32,12 +33,26 @@ pub async fn list_users( let limit = query.limit.unwrap_or(50).clamp(1, 200); let offset = query.offset.unwrap_or(0).max(0); let pattern = query.q.as_deref().map(|q| format!("%{}%", q.trim().replace(['%', '_'], ""))); - type Row = (Uuid, String, Option, Vec, bool, OffsetDateTime, Option, i64, i64, i64); + type Row = ( + Uuid, + String, + Option, + Vec, + bool, + OffsetDateTime, + Option, + i64, + i64, + i64, + Option, + ); let rows: Vec = sqlx::query_as( "SELECT u.id, u.email, u.display_name, u.roles, u.email_verified_at IS NOT NULL, u.created_at, u.last_login_at, \ (SELECT count(*) FROM charts c WHERE c.owner_id = u.id), \ (SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger l WHERE l.user_id = u.id AND l.unit = 'natal'), \ - (SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger l WHERE l.user_id = u.id AND l.unit = 'synastry') \ + (SELECT COALESCE(SUM(delta), 0)::bigint FROM credit_ledger l WHERE l.user_id = u.id AND l.unit = 'synastry'), \ + (SELECT e.expires_at FROM entitlements e \ + WHERE e.user_id = u.id AND e.entitlement = 'unlimited' AND e.expires_at > now()) \ FROM users u \ WHERE $1::text IS NULL OR u.email ILIKE $1 OR u.display_name ILIKE $1 \ ORDER BY u.created_at DESC LIMIT $2 OFFSET $3", @@ -49,11 +64,12 @@ pub async fn list_users( .await?; let users: Vec = rows .into_iter() - .map(|(id, email, name, roles, verified, created, last_login, charts, natal, synastry)| { + .map(|(id, email, name, roles, verified, created, last_login, charts, natal, synastry, unlimited)| { json!({ "id": id, "email": email, "display_name": name, "roles": roles, "email_verified": verified, "created_at": rfc3339(created), "last_login_at": rfc3339_opt(last_login), "charts": charts, "analyses_left": {"natal": natal, "synastry": synastry}, + "unlimited_until": rfc3339_opt(unlimited), }) }) .collect(); @@ -128,3 +144,37 @@ pub async fn adjust_credits( let balance = credits::balance(&mut *state.db.acquire().await?, id).await?; Ok((StatusCode::CREATED, Json(json!({ "user_id": id, "analyses_left": balance.view() })))) } + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +pub struct GrantPackage { + package: String, + note: Option, +} + +/// Gives a user a package from the catalog (a gift: no payment, price 0). +pub async fn grant_package( + State(state): St, + AdminUser(admin): AdminUser, + WithRejection(Path(id), _): IdPath, + WithRejection(Json(req), _): Body, +) -> ApiResult<(StatusCode, Json)> { + let package = packages::find(&req.package).ok_or(ApiError::NotFound("package"))?; + let exists: Option<(Uuid,)> = + sqlx::query_as("SELECT id FROM users WHERE id = $1").bind(id).fetch_optional(&state.db).await?; + exists.ok_or(ApiError::NotFound("user"))?; + let note = req.note.map(|n| n.trim().chars().take(500).collect::()).filter(|n| !n.is_empty()); + let mut tx = state.db.begin().await?; + let order = packages::grant(&mut tx, id, package, Source::Admin, Some(admin.id()), note.as_deref()).await?; + let balance = credits::balance(&mut tx, id).await?; + let unlimited = packages::unlimited_until(&mut tx, id).await?; + tx.commit().await?; + tracing::info!(admin = %admin.id(), user = %id, package = package.id, "package granted"); + Ok(( + StatusCode::CREATED, + Json(json!({ + "order_id": order, "user_id": id, "package": package.id, + "analyses_left": balance.view(), "unlimited_until": rfc3339_opt(unlimited), + })), + )) +} diff --git a/services/backend/src/routes/analyses.rs b/services/backend/src/routes/analyses.rs index f5d1417..853be1e 100644 --- a/services/backend/src/routes/analyses.rs +++ b/services/backend/src/routes/analyses.rs @@ -28,6 +28,7 @@ use crate::AppState; use crate::auth::AuthUser; use crate::credits::{self, Unit}; use crate::error::{ApiError, ApiResult}; +use crate::packages; use crate::views::{rfc3339, rfc3339_opt, sha256_hex}; use db::Role; @@ -118,9 +119,18 @@ async fn request( req: AnalysisRequest, ) -> ApiResult<(StatusCode, Json)> { let language = validate_locale(state, Some(req.language.as_deref().unwrap_or(&auth.user.locale)))?; - // Admins get detailed analyses free of charge. + // Admins and a running unlimited package (within its daily cap) use no unit. + let admin = auth.user.has_role(Role::Admin); + let unlimited = !admin && { + let mut conn = state.db.acquire().await?; + let until = packages::unlimited_until(&mut conn, auth.id()).await?; + if until.is_some() { + packages::check_fair_use(&mut conn, auth.id(), state.config.unlimited_daily_limit).await?; + } + until.is_some() + }; let unit = match target { - _ if auth.user.has_role(Role::Admin) => None, + _ if admin || unlimited => None, Target::Synastry { .. } => Some(Unit::Synastry), _ => Some(Unit::Natal), }; @@ -145,8 +155,14 @@ async fn queue( Target::Summary { chart_id, hash } => ("summary", hash, Some(*chart_id), None), Target::Synastry { synastry_id, hash } => ("synastry", hash, None, Some(*synastry_id)), }; - let prompt_version = &state.config.prompt_version; - let cache_key = sha256_hex(&format!("{kind}|{hash}|{prompt_version}|{model}|{language}")); + // The cache key leaves out the admin-edited prompt revision, so a chart keeps + // its analysis when the prompt changes; copying from another chart needs the same revision. + let base_version = &state.config.prompt_version; + let cache_key = sha256_hex(&format!("{kind}|{hash}|{base_version}|{model}|{language}")); + let prompt_version = &match super::prompts::current_revision(&state.db, kind, language).await? { + Some(id) => format!("{base_version}-r{id}"), + None => base_version.clone(), + }; // Already requested for this chart/synastry: return it. let existing: Option = sqlx::query_as(&format!( @@ -172,9 +188,11 @@ async fn queue( // The same chart elsewhere (another user, same birth data) was already analysed: copy it. let cached: Option<(Value, Option, Option)> = sqlx::query_as( - "SELECT content, input_tokens, output_tokens FROM analyses WHERE cache_key = $1 AND status = 'done' LIMIT 1", + "SELECT content, input_tokens, output_tokens FROM analyses \ + WHERE cache_key = $1 AND prompt_version = $2 AND status = 'done' LIMIT 1", ) .bind(&cache_key) + .bind(prompt_version) .fetch_optional(&state.db) .await?; if let Some((content, input_tokens, output_tokens)) = cached { diff --git a/services/backend/src/routes/charts.rs b/services/backend/src/routes/charts.rs index ce0c105..649f076 100644 --- a/services/backend/src/routes/charts.rs +++ b/services/backend/src/routes/charts.rs @@ -273,8 +273,9 @@ pub async fn update( }; let mut tx = state.db.begin().await?; if let Some((birth, result, hash)) = &recalculated { - // The old summary (and an admin's analyses) no longer match the chart. + // The old summary, the comparisons (and an admin's analyses) no longer match the chart. sqlx::query("DELETE FROM analyses WHERE chart_id = $1").bind(id).execute(&mut *tx).await?; + sqlx::query("DELETE FROM synastries WHERE chart1_id = $1 OR chart2_id = $1").bind(id).execute(&mut *tx).await?; sqlx::query("UPDATE charts SET birth_data = $1, result = $2, chart_hash = $3 WHERE id = $4") .bind(birth) .bind(result) @@ -322,11 +323,16 @@ async fn corrected_birth( return Err(ApiError::conflict("person_locked", persons::LOCKED_MESSAGE)); } let admin = auth.user.has_role(db::Role::Admin); - let (analysed, in_synastry): (bool, bool) = sqlx::query_as( - "SELECT EXISTS (SELECT 1 FROM analyses WHERE chart_id = $1 AND kind <> 'summary' AND status <> 'failed'), \ - EXISTS (SELECT 1 FROM synastries WHERE chart1_id = $1 OR chart2_id = $1)", + // The user's own comparisons with the person are deleted on correction (they + // no longer match), unless a paid analysis was written for one of them. + 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'), \ + EXISTS (SELECT 1 FROM synastries WHERE (chart1_id = $1 OR chart2_id = $1) AND owner_id <> $2)", ) .bind(chart.id) + .bind(auth.id()) .fetch_one(&state.db) .await?; if analysed && !admin { @@ -335,10 +341,10 @@ async fn corrected_birth( "Ehhez a személyhez már készült részletes elemzés, ezért az adatai nem módosíthatók.", )); } - if in_synastry { + if foreign_synastry { return Err(ApiError::conflict( "person_in_synastry", - "A személy szerepel egy összevetésben, ezért az adatai nem módosíthatók.", + "A személy szerepel valaki más összevetésében, ezért az adatai nem módosíthatók.", )); } calculate(state, birth).await diff --git a/services/backend/src/routes/mod.rs b/services/backend/src/routes/mod.rs index 382c8d9..d01e11d 100644 --- a/services/backend/src/routes/mod.rs +++ b/services/backend/src/routes/mod.rs @@ -11,6 +11,7 @@ mod analyses; mod auth; mod charts; mod payments; +mod prompts; mod shares; mod synastries; @@ -49,6 +50,7 @@ pub fn router(state: Arc) -> Router { Router::new() .route("/healthz", get(health)) .route("/v1/config", get(public_config)) + .route("/v1/packages", get(payments::catalog)) // login .route("/v1/auth/register", post(auth::register)) .route("/v1/auth/login", post(auth::login)) @@ -89,6 +91,11 @@ pub fn router(state: Arc) -> Router { .route("/v1/admin/users", get(admin::list_users)) .route("/v1/admin/users/{id}", patch(admin::update_user)) .route("/v1/admin/users/{id}/credits", post(admin::adjust_credits)) + .route("/v1/admin/users/{id}/packages", post(admin::grant_package)) + .route("/v1/admin/prompts", get(prompts::list)) + .route("/v1/admin/prompts/{kind}/{language}", axum::routing::put(prompts::save)) + .route("/v1/admin/prompts/{kind}/{language}/preview", post(prompts::start_preview)) + .route("/v1/admin/previews/{id}", get(prompts::get_preview)) .layer(cors(&state.config.cors_allowed_origins)) .layer( TraceLayer::new_for_http() @@ -122,7 +129,7 @@ async fn public_config(State(state): St) -> Json { "summary_model": c.summary_model, "password_login": c.password_login, "mock_payments": c.mock_payments, - "person_pack_size": c.person_pack_size, + "unlimited_daily_limit": c.unlimited_daily_limit, "password_min_length": crate::auth::MIN_PASSWORD_LEN, })) } diff --git a/services/backend/src/routes/payments.rs b/services/backend/src/routes/payments.rs index 9aa9acb..9b5a1ca 100644 --- a/services/backend/src/routes/payments.rs +++ b/services/backend/src/routes/payments.rs @@ -1,38 +1,49 @@ -//! Payments. Until Stripe is connected, `MOCK_PAYMENTS=true` turns on a -//! stand-in: "paying" grants what was bought right away (an analysis unit or -//! a person package), so the paid flow can be used end to end. +//! Packages and payments. Until Stripe is connected, `MOCK_PAYMENTS=true` +//! turns on a stand-in: "paying" grants the package right away, so the paid +//! flow can be used end to end. use axum::Json; use axum::extract::State; use axum_extra::extract::WithRejection; use serde::Deserialize; use serde_json::{Value, json}; -use uuid::Uuid; use super::{Body, St}; use crate::auth::AuthUser; use crate::credits::{self, Unit}; use crate::error::{ApiError, ApiResult}; +use crate::packages::{self, CATALOG, Source}; use crate::persons; +use crate::views::rfc3339; + +/// The package catalog (public). +pub async fn catalog() -> Json { + Json(json!({ "packages": CATALOG.iter().map(packages::Package::view).collect::>() })) +} #[derive(Deserialize)] #[serde(deny_unknown_fields)] pub struct MockPayment { - /// One analysis unit. + /// A package id from the catalog. + package: Option, + /// Shorthand: the cheapest package with one unit of this kind. unit: Option, - package: Option, } -#[derive(Debug, Clone, Copy, Deserialize)] -#[serde(rename_all = "snake_case")] -pub enum Package { - /// `PERSON_PACK_SIZE` more persons. - Persons, - /// Any number of persons. - PersonsUnlimited, +/// What the user has now: units left, person slots, the unlimited package. +pub async fn holdings(state: &crate::AppState, auth: &AuthUser) -> Result { + let mut conn = state.db.acquire().await?; + let balance = credits::balance(&mut conn, auth.id()).await?; + let persons = persons::slots(&mut conn, auth, state.config.free_person_slots).await?; + let until = packages::unlimited_until(&mut conn, auth.id()).await?; + Ok(json!({ + "analyses_left": balance.view(), + "persons": persons.view(), + "unlimited_until": until.map(rfc3339), + })) } -/// Grants an analysis unit or a person package as a (pretend) purchase. +/// Grants a package as a (pretend) purchase. pub async fn mock( State(state): St, auth: AuthUser, @@ -41,38 +52,17 @@ pub async fn mock( if !state.config.mock_payments { return Err(ApiError::NotFound("payment method")); } - let (unit, delta) = match (req.unit, req.package) { - (Some(unit), None) => (Some(unit), 1), - (None, Some(Package::Persons)) => (Some(Unit::Person), state.config.person_pack_size), - (None, Some(Package::PersonsUnlimited)) => (None, 0), - _ => return Err(ApiError::BadRequest("give either unit or package".into())), + let id = match (req.package.as_deref(), req.unit) { + (Some(id), None) => id, + (None, Some(Unit::Natal)) => "single", + (None, Some(Unit::Synastry)) => "addon_synastry", + (None, Some(Unit::Person)) => "addon_persons", + _ => return Err(ApiError::BadRequest("give either package or unit".into())), }; + let package = packages::find(id).ok_or(ApiError::NotFound("package"))?; let mut tx = state.db.begin().await?; - match unit { - Some(unit) => { - sqlx::query( - "INSERT INTO credit_ledger (id, user_id, unit, delta, reason, note) \ - VALUES ($1, $2, $3, $4, 'purchase', 'mock payment')", - ) - .bind(Uuid::now_v7()) - .bind(auth.id()) - .bind(unit.as_str()) - .bind(delta as i32) - .execute(&mut *tx) - .await?; - } - None => { - sqlx::query( - "INSERT INTO entitlements (user_id, entitlement, note) VALUES ($1, 'unlimited_persons', 'mock payment') \ - ON CONFLICT DO NOTHING", - ) - .bind(auth.id()) - .execute(&mut *tx) - .await?; - } - } - let balance = credits::balance(&mut tx, auth.id()).await?; - let persons = persons::slots(&mut tx, &auth, state.config.free_person_slots).await?; + packages::grant(&mut tx, auth.id(), package, Source::Mock, Some(auth.id()), Some("mock payment")).await?; tx.commit().await?; - Ok(Json(json!({ "analyses_left": balance.view(), "persons": persons.view() }))) + tracing::info!(user = %auth.id(), package = package.id, "mock payment"); + Ok(Json(holdings(&state, &auth).await?)) } diff --git a/services/backend/src/routes/prompts.rs b/services/backend/src/routes/prompts.rs new file mode 100644 index 0000000..512566e --- /dev/null +++ b/services/backend/src/routes/prompts.rs @@ -0,0 +1,280 @@ +//! Editable system prompts of the analyses (admin only). +//! +//! Every save adds a row to `prompt_revisions`; the newest row of a +//! (kind, language) is in force, `system` NULL meaning the built-in text. +//! New analyses record the revision in `prompt_version`, so analyses that +//! are already written or queued keep the text they were started with. +//! +//! A draft can be tried on one of the admin's own charts first: a row in +//! `prompt_previews` that the worker writes like an analysis, but it is never +//! shown to users, cached or charged. + +use analysis_prompt::{Kind, default_system, user_template}; +use axum::Json; +use axum::extract::{Path, State}; +use axum::http::StatusCode; +use axum_extra::extract::WithRejection; +use serde::Deserialize; +use serde_json::{Value, json}; +use sqlx::PgPool; +use time::OffsetDateTime; +use uuid::Uuid; + +use super::{Body, IdPath, St}; +use crate::AppState; +use crate::auth::AdminUser; +use crate::error::{ApiError, ApiResult}; +use crate::views::{rfc3339, rfc3339_opt}; + +/// The kinds whose prompt the admin page edits. +const EDITABLE: [Kind; 3] = [Kind::Summary, Kind::Natal, Kind::Synastry]; +const MAX_CHARS: usize = 50_000; +const HISTORY: i64 = 20; +/// Test runs of one admin waiting or being written at the same time. +const MAX_OPEN_PREVIEWS: i64 = 3; + +/// The revision id of an admin-edited prompt in force, `None` for the built-in one. +pub async fn current_revision(db: &PgPool, kind: &str, language: &str) -> Result, sqlx::Error> { + let row: Option<(i64, bool)> = sqlx::query_as( + "SELECT id, system IS NOT NULL FROM prompt_revisions WHERE kind = $1 AND language = $2 ORDER BY id DESC LIMIT 1", + ) + .bind(kind) + .bind(language) + .fetch_optional(db) + .await?; + Ok(row.filter(|(_, custom)| *custom).map(|(id, _)| id)) +} + +type RevisionRow = (i64, Option, OffsetDateTime, Option); + +async fn entry(db: &PgPool, kind: Kind, language: &str) -> Result { + let rows: Vec = sqlx::query_as( + "SELECT r.id, r.system, r.created_at, u.email FROM prompt_revisions r \ + LEFT JOIN users u ON u.id = r.created_by \ + WHERE r.kind = $1 AND r.language = $2 ORDER BY r.id DESC LIMIT $3", + ) + .bind(kind.as_str()) + .bind(language) + .bind(HISTORY) + .fetch_all(db) + .await?; + let default = default_system(kind, language); + let current = rows.first(); + let history: Vec = rows + .iter() + .map(|(id, system, at, by)| { + json!({"id": id, "custom": system.is_some(), "system": system, "created_at": rfc3339(*at), "created_by": by}) + }) + .collect(); + Ok(json!({ + "kind": kind.as_str(), + "language": language, + "system": current.and_then(|r| r.1.clone()).unwrap_or_else(|| default.clone()), + "custom": current.is_some_and(|r| r.1.is_some()), + "updated_at": current.map(|r| rfc3339(r.2)), + "updated_by": current.and_then(|r| r.3.clone()), + "default": default, + "user_template": user_template(kind), + "history": history, + })) +} + +pub async fn list(State(state): St, _admin: AdminUser) -> ApiResult> { + let mut prompts = Vec::new(); + for kind in EDITABLE { + for language in &state.config.supported_locales { + prompts.push(entry(&state.db, kind, language).await?); + } + } + Ok(Json(json!({ "prompts": prompts }))) +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +pub struct SavePrompt { + /// The new system prompt; `null` restores the built-in one. + system: Option, +} + +fn parse_target(state: &AppState, kind: &str, language: &str) -> Result { + let kind = Kind::parse(kind).filter(|k| EDITABLE.contains(k)).ok_or(ApiError::NotFound("prompt"))?; + if !state.config.supported_locales.iter().any(|l| l == language) { + return Err(ApiError::NotFound("prompt")); + } + Ok(kind) +} + +/// Trims a submitted prompt and checks its length. +fn clean_system(text: &str) -> Result { + let text = text.trim().replace("\r\n", "\n"); + if text.is_empty() { + return Err(ApiError::BadRequest("the prompt must not be empty".into())); + } + if text.chars().count() > MAX_CHARS { + return Err(ApiError::BadRequest(format!("the prompt is longer than {MAX_CHARS} characters"))); + } + Ok(text) +} + +pub async fn save( + State(state): St, + AdminUser(admin): AdminUser, + WithRejection(Path((kind, language)), _): WithRejection, ApiError>, + WithRejection(Json(req), _): Body, +) -> ApiResult> { + let kind = parse_target(&state, &kind, &language)?; + let default = default_system(kind, &language); + // The built-in text is stored as NULL, so later code changes reach it. + let system = match req.system.as_deref().map(clean_system).transpose()? { + Some(s) if s == default.trim() => None, + other => other, + }; + let current: Option<(Option,)> = sqlx::query_as( + "SELECT system FROM prompt_revisions WHERE kind = $1 AND language = $2 ORDER BY id DESC LIMIT 1", + ) + .bind(kind.as_str()) + .bind(&language) + .fetch_optional(&state.db) + .await?; + let unchanged = match ¤t { + Some((text,)) => *text == system, + None => system.is_none(), + }; + if !unchanged { + sqlx::query("INSERT INTO prompt_revisions (kind, language, system, created_by) VALUES ($1, $2, $3, $4)") + .bind(kind.as_str()) + .bind(&language) + .bind(&system) + .bind(admin.id()) + .execute(&state.db) + .await?; + tracing::info!(admin = %admin.id(), kind = kind.as_str(), %language, custom = system.is_some(), "prompt changed"); + } + Ok(Json(entry(&state.db, kind, &language).await?)) +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +pub struct StartPreview { + /// The draft to try (it need not be saved). + system: String, + /// One of the admin's own charts (own or a person), for a summary or natal analysis. + chart_id: Option, + /// One of the admin's own comparisons, for a synastry analysis. + synastry_id: Option, +} + +#[derive(sqlx::FromRow)] +struct PreviewRow { + id: Uuid, + kind: String, + chart_id: Option, + synastry_id: Option, + language: String, + model: String, + status: String, + content: Option, + error: Option, + model_used: Option, + input_tokens: Option, + output_tokens: Option, + cost_usd: Option, + created_at: OffsetDateTime, + started_at: Option, + completed_at: Option, +} + +const PREVIEW_COLUMNS: &str = "id, kind, chart_id, synastry_id, language, model, status, content, error, model_used, \ + input_tokens, output_tokens, cost_usd, created_at, started_at, completed_at"; + +impl PreviewRow { + fn view(self) -> Value { + let seconds = self.started_at.zip(self.completed_at).map(|(s, c)| (c - s).whole_seconds()); + json!({ + "id": self.id, "kind": self.kind, "chart_id": self.chart_id, "synastry_id": self.synastry_id, + "language": self.language, "model": self.model, "status": self.status, "content": self.content, + "error": self.error, "model_used": self.model_used, "input_tokens": self.input_tokens, + "output_tokens": self.output_tokens, "cost_usd": self.cost_usd, "created_at": rfc3339(self.created_at), + "completed_at": rfc3339_opt(self.completed_at), "seconds": seconds, + }) + } +} + +pub async fn start_preview( + State(state): St, + AdminUser(admin): AdminUser, + WithRejection(Path((kind, language)), _): WithRejection, ApiError>, + WithRejection(Json(req), _): Body, +) -> ApiResult<(StatusCode, Json)> { + let kind = parse_target(&state, &kind, &language)?; + let system = clean_system(&req.system)?; + // The target must be the admin's own: a chart, or for a synastry analysis a comparison. + let (chart_id, synastry_id, found) = match (kind, req.chart_id, req.synastry_id) { + (Kind::Synastry, None, Some(id)) => { + let row: Option<(Uuid,)> = sqlx::query_as("SELECT id FROM synastries WHERE id = $1 AND owner_id = $2") + .bind(id) + .bind(admin.id()) + .fetch_optional(&state.db) + .await?; + (None, Some(id), row.map(|_| "synastry")) + } + (Kind::Summary | Kind::Natal, Some(id), None) => { + let row: Option<(Uuid,)> = sqlx::query_as("SELECT id FROM charts WHERE id = $1 AND owner_id = $2") + .bind(id) + .bind(admin.id()) + .fetch_optional(&state.db) + .await?; + (Some(id), None, row.map(|_| "chart")) + } + (Kind::Synastry, ..) => return Err(ApiError::BadRequest("a synastry analysis needs synastry_id".into())), + _ => return Err(ApiError::BadRequest("this analysis needs chart_id".into())), + }; + if found.is_none() { + return Err(ApiError::NotFound(if synastry_id.is_some() { "synastry" } else { "chart" })); + } + let (open,): (i64,) = sqlx::query_as( + "SELECT count(*) FROM prompt_previews WHERE created_by = $1 AND status IN ('pending', 'running')", + ) + .bind(admin.id()) + .fetch_one(&state.db) + .await?; + if open >= MAX_OPEN_PREVIEWS { + return Err(ApiError::conflict( + "too_many_previews", + "Egyszerre legfeljebb három próba futhat. Várd meg, amíg valamelyik elkészül.", + )); + } + let model = match kind { + Kind::Summary => &state.config.summary_model, + _ => &state.config.analysis_model, + }; + let row: PreviewRow = sqlx::query_as(&format!( + "INSERT INTO prompt_previews (id, kind, chart_id, synastry_id, language, model, system, created_by) \ + VALUES ($1, $2, $3, $4, $5, $6, $7, $8) RETURNING {PREVIEW_COLUMNS}" + )) + .bind(Uuid::now_v7()) + .bind(kind.as_str()) + .bind(chart_id) + .bind(synastry_id) + .bind(&language) + .bind(model) + .bind(&system) + .bind(admin.id()) + .fetch_one(&state.db) + .await?; + Ok((StatusCode::ACCEPTED, Json(row.view()))) +} + +pub async fn get_preview( + State(state): St, + AdminUser(admin): AdminUser, + WithRejection(Path(id), _): IdPath, +) -> ApiResult> { + let row: Option = + sqlx::query_as(&format!("SELECT {PREVIEW_COLUMNS} FROM prompt_previews WHERE id = $1 AND created_by = $2")) + .bind(id) + .bind(admin.id()) + .fetch_optional(&state.db) + .await?; + Ok(Json(row.ok_or(ApiError::NotFound("preview"))?.view())) +} diff --git a/services/backend/src/tests.rs b/services/backend/src/tests.rs index f985a86..a6b6bf4 100644 --- a/services/backend/src/tests.rs +++ b/services/backend/src/tests.rs @@ -755,11 +755,7 @@ async fn admins_get_free_analyses_and_mock_payments_add_units(pool: PgPool) { #[sqlx::test(migrator = "db::MIGRATOR")] async fn persons_use_package_slots(pool: PgPool) { - let app = TestApp::with_config(pool, |c| { - c.free_person_slots = 1; - c.person_pack_size = 2; - }) - .await; + let app = TestApp::with_config(pool, |c| c.free_person_slots = 1).await; let anna = app.register("anna@example.com", "Anna").await; let own = app.chart(&anna, "Saját", true, "1990-03-15").await; assert_eq!(own["kind"], "own"); @@ -780,16 +776,15 @@ async fn persons_use_package_slots(pool: PgPool) { assert_eq!(r.status, StatusCode::NO_CONTENT); assert_eq!(persons(app.get("/v1/me", Some(&anna)).await.body)["left"], 0); - // a package adds two slots - let r = app.post("/v1/payments/mock", Some(&anna), json!({"package": "persons"})).await; - assert_eq!(r.body["persons"], json!({"used": 1, "limit": 3, "left": 2, "unlimited": false}), "{}", r.body); + // a person package adds five slots + let r = app.post("/v1/payments/mock", Some(&anna), json!({"package": "addon_persons"})).await; + assert_eq!(r.body["persons"], json!({"used": 1, "limit": 6, "left": 5, "unlimited": false}), "{}", r.body); let second = app.chart(&anna, "Cili", false, "1986-01-01").await; app.chart(&anna, "Dani", false, "1987-01-01").await; - let r = app.post("/v1/charts", Some(&anna), new_person("1988-01-01")).await; - assert_eq!(r.status, StatusCode::CONFLICT); + assert_eq!(persons(app.get("/v1/me", Some(&anna)).await.body)["left"], 3); // the unlimited package - let r = app.post("/v1/payments/mock", Some(&anna), json!({"package": "persons_unlimited"})).await; + let r = app.post("/v1/payments/mock", Some(&anna), json!({"package": "unlimited"})).await; assert_eq!(r.body["persons"], json!({"used": 3, "limit": null, "left": null, "unlimited": true})); app.chart(&anna, "Emma", false, "1988-01-01").await; let list = app.get("/v1/charts", Some(&anna)).await.body; @@ -827,3 +822,249 @@ async fn persons_use_package_slots(pool: PgPool) { let r = app.call("PATCH", &format!("/v1/charts/{pid}"), Some(&admin), Some(corrected)).await; assert_eq!(r.status, StatusCode::OK, "{}", r.body); } + +#[sqlx::test(migrator = "db::MIGRATOR")] +async fn admins_edit_analysis_prompts(pool: PgPool) { + let app = TestApp::new(pool.clone()).await; + let admin = app.register("admin@example.com", "Admin").await; + let anna = app.register("anna@example.com", "Anna").await; + assert_eq!(app.get("/v1/admin/prompts", Some(&anna)).await.status, StatusCode::FORBIDDEN); + + let r = app.get("/v1/admin/prompts", Some(&admin)).await; + assert_eq!(r.status, StatusCode::OK, "{}", r.body); + let prompts = r.body["prompts"].as_array().unwrap(); + let keys: Vec = + prompts.iter().map(|p| format!("{}/{}", p["kind"], p["language"]).replace('"', "")).collect(); + assert_eq!(keys, ["summary/hu", "summary/en", "natal/hu", "natal/en", "synastry/hu", "synastry/en"]); + let natal = &prompts[2]; + assert_eq!((&natal["custom"], &natal["system"]), (&json!(false), &natal["default"])); + assert!(natal["user_template"].as_str().unwrap().contains("{chart data}")); + let default = natal["default"].as_str().unwrap().to_string(); + + let put = |body: Value, uri: &'static str| app.call("PUT", uri, Some(&admin), Some(body)); + assert_eq!(put(json!({"system": " "}), "/v1/admin/prompts/natal/hu").await.status, StatusCode::BAD_REQUEST); + assert_eq!(put(json!({"system": "x"}), "/v1/admin/prompts/composite/hu").await.status, StatusCode::NOT_FOUND); + assert_eq!(put(json!({"system": "x"}), "/v1/admin/prompts/natal/de").await.status, StatusCode::NOT_FOUND); + // saving the built-in text keeps the built-in prompt + let r = put(json!({"system": default}), "/v1/admin/prompts/natal/hu").await; + assert_eq!( + (r.status, &r.body["custom"], r.body["history"].as_array().unwrap().len()), + (StatusCode::OK, &json!(false), 0) + ); + + // an analysis written with the built-in prompt + let chart = app.chart(&anna, "Saját", true, "1990-03-15").await; + let uri = format!("/v1/charts/{}/analyses", chart["id"].as_str().unwrap()); + grant_units(&app, &anna, "natal", 1).await; + let r = app.call("POST", &uri, Some(&anna), None).await; + assert_eq!((r.status, r.body["prompt_version"].as_str()), (StatusCode::ACCEPTED, Some("v1"))); + let first = r.body["id"].as_str().unwrap().to_string(); + sqlx::query("UPDATE analyses SET status = 'done', content = '{}', completed_at = now() WHERE id = $1::uuid") + .bind(&first) + .execute(&pool) + .await + .unwrap(); + + let r = put(json!({"system": "Saját szabályok.\r\n"}), "/v1/admin/prompts/natal/hu").await; + assert_eq!( + (&r.body["custom"], r.body["system"].as_str(), r.body["updated_by"].as_str()), + (&json!(true), Some("Saját szabályok."), Some("admin@example.com")) + ); + let revision = r.body["history"][0]["id"].as_i64().unwrap(); + let r = put(json!({"system": "Saját szabályok."}), "/v1/admin/prompts/natal/hu").await; + assert_eq!(r.body["history"].as_array().unwrap().len(), 1); // unchanged: no new revision + + // the chart keeps its analysis; the same birth data elsewhere is written anew with the edited prompt + let r = app.call("POST", &uri, Some(&anna), None).await; + assert_eq!((r.status, r.body["id"].as_str()), (StatusCode::OK, Some(first.as_str()))); + let bela = app.register("bela@example.com", "Béla").await; + let same = app.chart(&bela, "Saját", true, "1990-03-15").await; + grant_units(&app, &bela, "natal", 1).await; + let r = app.call("POST", &format!("/v1/charts/{}/analyses", same["id"].as_str().unwrap()), Some(&bela), None).await; + let expected = format!("v1-r{revision}"); + assert_eq!((r.status, r.body["prompt_version"].as_str()), (StatusCode::ACCEPTED, Some(expected.as_str()))); + + // back to the built-in prompt + let r = put(json!({"system": null}), "/v1/admin/prompts/natal/hu").await; + assert_eq!((&r.body["custom"], r.body["system"].as_str()), (&json!(false), Some(default.as_str()))); + assert_eq!(r.body["history"].as_array().unwrap().len(), 2); +} + +/// Starts a summary prompt test run on `chart`. +async fn start_preview(app: &TestApp, chart: &Value, token: &str) -> Response { + let body = json!({"system": " Próba szabályok. ", "chart_id": chart["id"]}); + app.call("POST", "/v1/admin/prompts/summary/hu/preview", Some(token), Some(body)).await +} + +#[sqlx::test(migrator = "db::MIGRATOR")] +async fn admins_try_prompt_drafts_on_own_charts(pool: PgPool) { + let app = TestApp::new(pool.clone()).await; + let admin = app.register("admin@example.com", "Admin").await; + let anna = app.register("anna@example.com", "Anna").await; + let own = app.chart(&admin, "Saját", true, "1990-03-15").await; + let annas = app.chart(&anna, "Saját", true, "1991-05-01").await; + + assert_eq!(start_preview(&app, &own, &anna).await.status, StatusCode::FORBIDDEN); + assert_eq!(start_preview(&app, &annas, &admin).await.status, StatusCode::NOT_FOUND); // only own charts + let r = start_preview(&app, &own, &admin).await; + assert_eq!(r.status, StatusCode::ACCEPTED, "{}", r.body); + assert_eq!( + (r.body["status"].as_str(), r.body["kind"].as_str(), r.body["model"].as_str()), + (Some("pending"), Some("summary"), Some("anthropic/claude-summary")) + ); + let id = r.body["id"].as_str().unwrap().to_string(); + let (system,): (String,) = sqlx::query_as("SELECT system FROM prompt_previews WHERE id = $1::uuid") + .bind(&id) + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(system, "Próba szabályok."); + + // nothing reaches the chart's analyses, and the saved prompt is unchanged + let r = app.get(&format!("/v1/charts/{}/analyses", own["id"].as_str().unwrap()), Some(&admin)).await; + assert!( + r.body["analyses"].as_array().unwrap().iter().all(|a| a["kind"] == "summary" && a["prompt_version"] == "v1") + ); + assert_eq!(app.get("/v1/admin/prompts", Some(&admin)).await.body["prompts"][0]["custom"], json!(false)); + + let r = app.get(&format!("/v1/admin/previews/{id}"), Some(&admin)).await; + assert_eq!((r.status, r.body["status"].as_str()), (StatusCode::OK, Some("pending"))); + assert_eq!(app.get(&format!("/v1/admin/previews/{id}"), Some(&anna)).await.status, StatusCode::FORBIDDEN); + + // at most three at a time + start_preview(&app, &own, &admin).await; + start_preview(&app, &own, &admin).await; + let r = start_preview(&app, &own, &admin).await; + assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::CONFLICT, Some("too_many_previews"))); + let body = json!({"system": "Részletes próba.", "chart_id": own["id"]}); + sqlx::query("UPDATE prompt_previews SET status = 'done'").execute(&pool).await.unwrap(); + let r = app.call("POST", "/v1/admin/prompts/natal/hu/preview", Some(&admin), Some(body)).await; + assert_eq!((r.status, r.body["model"].as_str()), (StatusCode::ACCEPTED, Some("anthropic/claude-test"))); + + // a relationship analysis is tried on one of the admin's comparisons + let other = app.chart(&admin, "Béla", false, "1985-08-02").await; + let syn = app.post("/v1/synastries", Some(&admin), json!({"chart1_id": own["id"], "chart2_id": other["id"]})).await; + let uri = "/v1/admin/prompts/synastry/hu/preview"; + let r = app.call("POST", uri, Some(&admin), Some(json!({"system": "Próba.", "chart_id": own["id"]}))).await; + assert_eq!(r.status, StatusCode::BAD_REQUEST); + let r = app.call("POST", uri, Some(&admin), Some(json!({"system": "Próba.", "synastry_id": syn.body["id"]}))).await; + assert_eq!( + (r.status, r.body["synastry_id"].as_str()), + (StatusCode::ACCEPTED, syn.body["id"].as_str()), + "{}", + r.body + ); +} + +#[sqlx::test(migrator = "db::MIGRATOR")] +async fn comparisons_with_persons(pool: PgPool) { + let app = TestApp::new(pool).await; + let anna = app.register("anna@example.com", "Anna").await; + let own = app.chart(&anna, "Saját", true, "1990-03-15").await; + let bela = app.chart(&anna, "Béla", false, "1985-08-02").await; + let compare = || app.post("/v1/synastries", Some(&anna), json!({"chart1_id": own["id"], "chart2_id": bela["id"]})); + let r = compare().await; + assert_eq!(r.status, StatusCode::CREATED, "{}", r.body); + let first = r.body["id"].as_str().unwrap().to_string(); + assert_eq!((&r.body["chart1"]["is_primary"], &r.body["chart2"]["label"]), (&json!(true), &json!("Béla"))); + + // correcting the person removes the comparison that no longer matches + let uri = format!("/v1/charts/{}", bela["id"].as_str().unwrap()); + let corrected = |date: &str| json!({"birth": {"date": date, "time": "10:00", "country": "HU", "place": "Szeged"}}); + let r = app.call("PATCH", &uri, Some(&anna), Some(corrected("1985-08-03"))).await; + assert_eq!(r.status, StatusCode::OK, "{}", r.body); + assert_eq!(app.get(&format!("/v1/synastries/{first}"), Some(&anna)).await.status, StatusCode::NOT_FOUND); + + // after a paid relationship analysis the person is fixed + let r = compare().await; + assert_eq!(r.status, StatusCode::CREATED); + let id = r.body["id"].as_str().unwrap(); + grant_units(&app, &anna, "synastry", 1).await; + let r = app.call("POST", &format!("/v1/synastries/{id}/analyses"), Some(&anna), None).await; + assert_eq!(r.status, StatusCode::ACCEPTED, "{}", r.body); + let r = app.call("PATCH", &uri, Some(&anna), Some(corrected("1985-08-04"))).await; + assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::CONFLICT, Some("person_analysed"))); + assert_eq!(app.get("/v1/synastries", Some(&anna)).await.body["synastries"].as_array().unwrap().len(), 1); +} + +/// An admin (or not) gives `user` a package. +async fn grant_package(app: &TestApp, token: &str, user: &str, package: &str) -> Response { + let body = json!({"package": package, "note": "ajándék"}); + app.call("POST", &format!("/v1/admin/users/{user}/packages"), Some(token), Some(body)).await +} + +#[sqlx::test(migrator = "db::MIGRATOR")] +async fn packages_grant_units_and_unlimited(pool: PgPool) { + let app = TestApp::new(pool.clone()).await; + let admin = app.register("admin@example.com", "Admin").await; + let anna = app.register("anna@example.com", "Anna").await; + let anna_id = app.get("/v1/me", Some(&anna)).await.body["user"]["id"].as_str().unwrap().to_string(); + + // the catalog is public + let r = app.get("/v1/packages", None).await; + let ids: Vec<&str> = r.body["packages"].as_array().unwrap().iter().map(|p| p["id"].as_str().unwrap()).collect(); + assert_eq!(ids, ["single", "couple", "family", "unlimited", "addon_synastry", "addon_persons"]); + assert_eq!( + (&r.body["packages"][2]["badge"], &r.body["packages"][2]["per_analysis_huf"]), + (&json!("Legnépszerűbb"), &json!(1090)) + ); + + // an admin gives a package as a gift + assert_eq!(grant_package(&app, &anna, &anna_id, "family").await.status, StatusCode::FORBIDDEN); + assert_eq!(grant_package(&app, &admin, &anna_id, "gold").await.status, StatusCode::NOT_FOUND); + let r = grant_package(&app, &admin, &anna_id, "family").await; + assert_eq!( + (r.status, &r.body["analyses_left"]), + (StatusCode::CREATED, &json!({"natal": 6, "synastry": 5})), + "{}", + r.body + ); + let me = app.get("/v1/me", Some(&anna)).await.body; + assert_eq!((&me["persons"]["limit"], &me["unlimited_until"]), (&json!(10), &Value::Null)); // 5 free + 5 + let (source, price): (String, i32) = + sqlx::query_as("SELECT source, price_huf FROM package_orders WHERE package = 'family'") + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!((source.as_str(), price), ("admin", 0)); + + // a (mock) purchase adds to it and records the price + let r = app.post("/v1/payments/mock", Some(&anna), json!({"package": "couple"})).await; + assert_eq!(r.body["analyses_left"], json!({"natal": 8, "synastry": 6}), "{}", r.body); + let (price,): (i32,) = + sqlx::query_as("SELECT price_huf FROM package_orders WHERE package = 'couple'").fetch_one(&pool).await.unwrap(); + assert_eq!(price, 6990); + + // unlimited: a year, and a second one extends it + let bela = app.register("bela@example.com", "Béla").await; + let bela_id = app.get("/v1/me", Some(&bela)).await.body["user"]["id"].as_str().unwrap().to_string(); + grant_package(&app, &admin, &bela_id, "unlimited").await; + let r = grant_package(&app, &admin, &bela_id, "unlimited").await; + let until = time::OffsetDateTime::parse( + r.body["unlimited_until"].as_str().unwrap(), + &time::format_description::well_known::Rfc3339, + ) + .unwrap(); + let days = (until - time::OffsetDateTime::now_utc()).whole_days(); + assert!((725..=733).contains(&days), "{days}"); + assert_eq!(app.get("/v1/me", Some(&bela)).await.body["persons"]["unlimited"], true); + + // analyses use no unit, up to the daily cap (3 in tests) + for (i, date) in ["1980-01-01", "1981-01-01", "1982-01-01"].into_iter().enumerate() { + let chart = app.chart(&bela, &format!("P{i}"), i == 0, date).await; + let r = app + .call("POST", &format!("/v1/charts/{}/analyses", chart["id"].as_str().unwrap()), Some(&bela), None) + .await; + assert_eq!((r.status, &r.body["credits_charged"]), (StatusCode::ACCEPTED, &json!(0)), "{}", r.body); + } + let fourth = app.chart(&bela, "P3", false, "1983-01-01").await; + let uri = format!("/v1/charts/{}/analyses", fourth["id"].as_str().unwrap()); + let r = app.call("POST", &uri, Some(&bela), None).await; + assert_eq!((r.status, r.body["error"]["code"].as_str()), (StatusCode::TOO_MANY_REQUESTS, Some("fair_use_limit"))); + + // after it ends, units are needed again + sqlx::query("UPDATE entitlements SET expires_at = now() - interval '1 day'").execute(&pool).await.unwrap(); + let r = app.call("POST", &uri, Some(&bela), None).await; + assert_eq!(r.status, StatusCode::PAYMENT_REQUIRED); + assert_eq!(app.get("/v1/me", Some(&bela)).await.body["unlimited_until"], Value::Null); +} diff --git a/services/frontend/README.md b/services/frontend/README.md index 31c2444..c5c9a2d 100644 --- a/services/frontend/README.md +++ b/services/frontend/README.md @@ -11,10 +11,15 @@ Next.js (App Router, TypeScript) webes felület. A compose-ban a **3001-es** por - **saját születési adatok**: dátum, idő (vagy „nem tudom”), ország és település helykeresővel. Mentéskor kiszámolja a képletet, és megmutatja a pozíciókat (bolygók, tengelyek, házcsúcsok). - A javított adatokból új képlet lesz (a backend a születési adatot nem módosítja), és az lesz a saját képlet. - Ha a megadott időpont az óraátállítás miatt kétszer is előfordult, a felület megkérdezi, melyikről van szó. +- **Összevetések** (`/osszevetesek`, szinasztria): a saját és a felvett személyek képletei közül bármelyik kettő összevethető; a személykártyán és a személy képletoldalán „Összevetés velem” gomb is van. Az összevetés oldala (`/osszevetesek/{id}`): + - kettős kör: belül az első fél bolygói és házai, kívül a második fél bolygói, középen a köztük lévő főfényszögek; + - a fényszögek jelleg szerint (harmonikus, feszültebb, együttállás); + - fülek: fizetős kapcsolati elemzés (`synastry` egység), a két fél közti fényszögmátrix, házátfedések, kompozit, részletes lista. - **Admin** (`/admin`, csak `admin` szerepkörrel; másnak 404): - felhasználók keresése; - szerepkörök be- és kikapcsolása (felhasználó, prémium, VIP, szerző, admin); - - elemzések jóváírása típusonként (képlet, szinasztria). + - elemzések jóváírása típusonként (képlet, szinasztria); + - **Promptok** (`/admin/promptok`): a tömör összefoglaló, a részletes és a kapcsolati elemzés system promptja szerkeszthető, változatokkal; mentés előtt egy saját képleten vagy összevetésen kipróbálható. - **Jogosultság:** a belépést nem igénylő oldalakon kívül minden oldal a szerveren ellenőrzi a munkamenetet; belépés nélkül a belépőoldalra irányít, majd vissza. ## Felépítés diff --git a/services/frontend/src/app/admin/AdminUsers.tsx b/services/frontend/src/app/admin/AdminUsers.tsx index c6955c6..3ad06f4 100644 --- a/services/frontend/src/app/admin/AdminUsers.tsx +++ b/services/frontend/src/app/admin/AdminUsers.tsx @@ -2,9 +2,10 @@ import { useCallback, useEffect, useState } from "react"; +import { huf, usePackages } from "@/components/PackageCards"; import { api, errorText } from "@/lib/api"; import { ROLE_LABELS, formatDate } from "@/lib/astro"; -import type { AdminUser, Role } from "@/lib/types"; +import type { AdminUser, Package, Role } from "@/lib/types"; const EDITABLE_ROLES: Role[] = ["user", "creator", "admin"]; const UNITS: { value: "natal" | "synastry"; label: string }[] = [ @@ -16,6 +17,7 @@ export function AdminUsers({ selfId }: { selfId: string }) { const [query, setQuery] = useState(""); const [users, setUsers] = useState(null); const [error, setError] = useState(null); + const packages = usePackages() ?? []; const load = useCallback(async (q: string) => { try { @@ -62,6 +64,7 @@ export function AdminUsers({ selfId }: { selfId: string }) { Felhasználó Szerepkörök Részletes elemzések + Csomag Képletek Regisztrált Utoljára belépett @@ -73,6 +76,7 @@ export function AdminUsers({ selfId }: { selfId: string }) { key={u.id} user={u} isSelf={u.id === selfId} + packages={packages} onChange={(next) => setUsers((list) => list?.map((x) => (x.id === next.id ? next : x)) ?? null)} /> ))} @@ -84,7 +88,17 @@ export function AdminUsers({ selfId }: { selfId: string }) { ); } -function UserRow({ user, isSelf, onChange }: { user: AdminUser; isSelf: boolean; onChange: (u: AdminUser) => void }) { +function UserRow({ + user, + isSelf, + packages, + onChange, +}: { + user: AdminUser; + isSelf: boolean; + packages: Package[]; + onChange: (u: AdminUser) => void; +}) { const [status, setStatus] = useState<{ ok: boolean; text: string } | null>(null); const [busy, setBusy] = useState(false); const [delta, setDelta] = useState(""); @@ -200,9 +214,84 @@ function UserRow({ user, isSelf, onChange }: { user: AdminUser; isSelf: boolean; )} + + + {user.charts} {formatDate(user.created_at)} {formatDate(user.last_login_at, true)} ); } + +/** Gives the user a package from the catalog (a gift: nothing is paid). */ +function PackageGrant({ + user, + packages, + onChange, +}: { + user: AdminUser; + packages: Package[]; + onChange: (u: AdminUser) => void; +}) { + const [id, setId] = useState(""); + const [busy, setBusy] = useState(false); + const [status, setStatus] = useState<{ ok: boolean; text: string } | null>(null); + + async function give(e: React.FormEvent) { + e.preventDefault(); + const pkg = packages.find((p) => p.id === id); + if (!pkg) return; + setBusy(true); + setStatus(null); + try { + const res = await api<{ analyses_left: AdminUser["analyses_left"]; unlimited_until: string | null }>( + `/admin/users/${user.id}/packages`, + { body: { package: pkg.id, note: "admin ajándék" } }, + ); + onChange({ ...user, analyses_left: res.analyses_left, unlimited_until: res.unlimited_until }); + setStatus({ ok: true, text: `${pkg.name} kiosztva` }); + setId(""); + } catch (err) { + setStatus({ ok: false, text: errorText(err) }); + } finally { + setBusy(false); + } + } + + return ( +
+ {user.unlimited_until && ( + Korlátlan {formatDate(user.unlimited_until).replace(/\.$/, "")}-ig + )} +
+ + + +
+ {status && ( + + {status.text} + + )} +
+ ); +} diff --git a/services/frontend/src/app/admin/page.tsx b/services/frontend/src/app/admin/page.tsx index 9f65c2e..a8da261 100644 --- a/services/frontend/src/app/admin/page.tsx +++ b/services/frontend/src/app/admin/page.tsx @@ -1,6 +1,7 @@ import type { Metadata } from "next"; import { notFound } from "next/navigation"; +import { AdminNav } from "@/components/AdminNav"; import { requireMe } from "@/lib/server"; import { AdminUsers } from "./AdminUsers"; @@ -13,9 +14,10 @@ export default async function AdminPage() { if (!me.user.roles.includes("admin")) notFound(); return (
+

Felhasználók

-

Szerepkörök kezelése és részletes elemzések jóváírása (ajándék, reklamáció). A vásárlások is ide könyvelődnek majd.

+

Szerepkörök kezelése, csomagok kiosztása és elemzések jóváírása (ajándék, reklamáció).

diff --git a/services/frontend/src/app/admin/promptok/AdminPrompts.tsx b/services/frontend/src/app/admin/promptok/AdminPrompts.tsx new file mode 100644 index 0000000..2ff9f8d --- /dev/null +++ b/services/frontend/src/app/admin/promptok/AdminPrompts.tsx @@ -0,0 +1,283 @@ +"use client"; + +import { useEffect, useState } from "react"; + +import { Tabs } from "@/components/Tabs"; +import { api, errorText } from "@/lib/api"; +import { formatDate } from "@/lib/astro"; +import type { AdminPrompt, ChartListItem, PromptKind } from "@/lib/types"; + +import { PromptTrial } from "./PromptTrial"; + +const KINDS: { kind: PromptKind; id: string; label: string; about: string }[] = [ + { + kind: "summary", + id: "osszefoglalo", + label: "Tömör összefoglaló", + about: "Ingyenes, a képlet oldalán a „Röviden” blokk: egy cím és 3–4 mondat. Minden új képlethez magától elkészül.", + }, + { + kind: "natal", + id: "reszletes", + label: "Részletes elemzés", + about: "Fizetős, hat fejezet, erősségek, kihívások és útravaló. Kérésre készül.", + }, + { + kind: "synastry", + id: "kapcsolati", + label: "Kapcsolati elemzés", + about: "Fizetős összevetés-elemzés két képletről: öt fejezet, erősségek, kihívások és útravaló. Kérésre készül.", + }, +]; + +const LANGUAGES: Record = { hu: "Magyar", en: "Angol" }; + +export function AdminPrompts() { + const [prompts, setPrompts] = useState(null); + const [charts, setCharts] = useState([]); + const [error, setError] = useState(null); + + useEffect(() => { + api<{ prompts: AdminPrompt[] }>("/admin/prompts") + .then((d) => setPrompts(d.prompts)) + .catch((e) => setError(errorText(e))); + api<{ charts: ChartListItem[] }>("/charts") + .then((d) => setCharts(d.charts)) + .catch(() => setCharts([])); + }, []); + + if (error) { + return ( +

+ {error} +

+ ); + } + if (!prompts) return

Betöltés…

; + + const replace = (next: AdminPrompt) => + setPrompts((all) => all?.map((p) => (p.kind === next.kind && p.language === next.language ? next : p)) ?? null); + + return ( +
+ ({ + id: k.id, + label: k.label, + content: ( + p.kind === k.kind)} + charts={charts} + onSaved={replace} + /> + ), + }))} + /> +
+ ); +} + +function KindPrompts({ + about, + prompts, + charts, + onSaved, +}: { + about: string; + prompts: AdminPrompt[]; + charts: ChartListItem[]; + onSaved: (p: AdminPrompt) => void; +}) { + const [language, setLanguage] = useState(prompts[0]?.language ?? "hu"); + const prompt = prompts.find((p) => p.language === language) ?? prompts[0]; + if (!prompt) return null; + return ( +
+
+

{about}

+ {prompts.length > 1 && ( +
+ + +
+ )} +
+ +
+ ); +} + +function PromptEditor({ + prompt, + charts, + onSaved, +}: { + prompt: AdminPrompt; + charts: ChartListItem[]; + onSaved: (p: AdminPrompt) => void; +}) { + const [draft, setDraft] = useState(prompt.system); + const [busy, setBusy] = useState(false); + const [error, setError] = useState(null); + const [saved, setSaved] = useState(false); + const dirty = draft.trim() !== prompt.system.trim(); + const id = `prompt-${prompt.kind}-${prompt.language}`; + + useEffect(() => { + if (!dirty) return; + const warn = (e: BeforeUnloadEvent) => e.preventDefault(); + window.addEventListener("beforeunload", warn); + return () => window.removeEventListener("beforeunload", warn); + }, [dirty]); + + async function save(system: string | null) { + setBusy(true); + setError(null); + setSaved(false); + try { + const next = await api(`/admin/prompts/${prompt.kind}/${prompt.language}`, { + method: "PUT", + body: { system }, + }); + onSaved(next); + setDraft(next.system); + setSaved(true); + } catch (e) { + setError(errorText(e)); + } finally { + setBusy(false); + } + } + + return ( +
+
+ {prompt.custom ? ( + Szerkesztett + ) : ( + Alapértelmezett + )} + {prompt.updated_at && ( + + Utoljára mentve: {formatDate(prompt.updated_at, true)} + {prompt.updated_by ? ` · ${prompt.updated_by}` : ""} + + )} +
+ +
+ +