Bind season calendar and confirmed fixture rescheduling to engine (by Codex)

This commit is contained in:
Codex committed 2026-10-28 14:42:25 +01:00
1 parent 7e170a00c7
commit 6119d7f21e
17 files changed
+388 -16

No files matched your search

+8
View File
@@ -30,3 +30,11 @@ body.matchday .calendar-day.has-match {color:#e1c68b;}
body.matchday .calendar-day.selected-day {background-color:#d48c7b26;color:#ffe5de;}
body.matchday .calendar-outline {border-color:#e5a19770;}
body.matchday #calendar-country,body.matchday #calendar-league {decorator:linear-gradient(180deg,#e8d6dc12,#a1a0aa0d);}
/* Generic competition dates do not claim that the active club has a fixture. */
.calendar-event-mark {position:absolute;left:43%;bottom:4dp;width:8dp;height:5dp;border-radius:2dp;background-color:var(--muted);pointer-events:none;}
.calendar-day.valid-target .calendar-event-mark {background-color:var(--accent);width:16dp;left:36%;height:5dp;}
.calendar-day.rescheduled-date .calendar-event-mark {background-color:var(--accent);}
/* Fixed scope labels have no dropdown caret and need symmetric padding. */
#calendar-country.engine-calendar-label,#calendar-league.engine-calendar-label {padding-right:24dp;}
+1 -1
View File
@@ -6,7 +6,7 @@ Die normale Classic-Konfiguration bleibt unverändert; die neue Oberfläche
wird ausdrücklich mit `OPENBMH_BUILD_MODERN_UI=ON` gebaut.
Der [opt-in Engine-Einstieg](integration/ENGINE_ENTRY.md) lädt inzwischen eine
echte Modern-OBS-Karriere und bindet Schreibtisch, Trainingslager, Aufstellung, Taktik, Training, Bank, Eintrittspreis, Umfeld, Werbung und Spielerverträge an die
echte Modern-OBS-Karriere und bindet Schreibtisch, Trainingslager, Aufstellung, Taktik, Training, Bank, Eintrittspreis, Umfeld, Werbung, Spielerverträge, Vereinskalender und Spielverlegung an die
Session. Kader und Profile zeigen die tatsächlichen Sessionwerte; Spielertausch
verwendet die bestätigte Engineaktion. Preisbestätigung, Buchung und Speichern als neue OBS-Datei sind echte
Engineoperationen. Dieser Einstieg ist auf diesen Umfang begrenzt; die übrigen
+28
View File
@@ -1,5 +1,33 @@
# Kalender · native Modern UI
## Echter Engine-Einstieg · 28. Oktober 2026
`--ui-career` verwendet jetzt denselben Zwölfmonatsrenderer mit einem vollständigen
`calendar`-Read von `meta.season.startDate` bis `endDate`. Die Geometrie erzeugt
nur Monatstage und Gregorianische Wochentage; sie erzeugt keine Ligapartien.
Alle konkreten Paarungen, Runden, Status, Ergebnisse und verlegten Termine kommen
unverändert aus der Engine. Datumsauswahl ist ein lokaler UI-Zustand und verändert
weder Sessionrevision, Geld, Spieltag noch Zufall.
Gelbe Termine haben eine tatsächliche eigene Kalenderpartie; Freundschaftstage
verwenden ihre vorhandene grüne Markierung. Kleine neutrale Marken zeigen
allgemeine Wettbewerbstermine. Ein Pokal- oder Länderspieltermin ohne gelieferte
Paarung wird als solcher benannt, ohne eigene Teilnahme oder einen Gegner zu
erfinden. Fehlende Termine heißen „keine eingetragenen Termine“, nicht pauschal
„spielfrei“. Nach einer Verlegung nennt die Terminzeile auch das ursprüngliche
Datum. Die Bezeichnungen stammen aus den gelieferten Ereignisarten.
Der erste Anschluss betrifft den Vereinskalender. Land und Liga zeigen die
aktuelle Zuordnung, bleiben aber lesend, bis die Engine Kalender anderer Ligen
liefert. Diese Felder besitzen symmetrische Innenabstände, da kein Dropdownpfeil
aktiv ist. Der Nationalkalender und die Freundschaftsspielplanung erhalten eigene
Anschlusspakete; sie werden nicht mit Vereins-Demodaten befüllt.
Private Nachweise mit drei Themes/1080p, Silver/720p und tatsächlichen OBS-Dateien:
`bmh_4k_ui/docs/qa/engine-calendar-2026-10-28/`.
## Getrennte Präsentationsdemo
Stand: 24. Oktober 2026. Quelle ist das unveränderte private HTML-Mockup
`bmh_4k_ui`, Referenzrevision `a7f8e39c8cb562a09d85dabae81e62a981afeb85`:
`desktop/management-menus.js`, `league-preview.js`, `table-window.css` und
+39
View File
@@ -1,5 +1,44 @@
# Spiel verlegen · native Modern UI
## Echter Engine-Einstieg · 28. Oktober 2026
`--ui-career` bindet das vorhandene Planungsfenster an `calendar` und `scheduling`.
Ausgangspartien und ihre jeweiligen Zieltermine kommen vollständig aus der
Engine. Der Client berechnet keine freien Tage, Samstagspläne, Mindestabstände
oder eigene Terminverbote. Er bindet eine Ausgangsauswahl an die unveränderte
`move:`-ID, Karriere, Manager und Revision. Nicht angebotene Ziele lassen den
Aktionsknopf gesperrt; die verfügbare Zielmenge wird grün markiert.
Erst die sichtbare Bestätigung von Paarung, altem und neuem Datum sendet
`fixture.reschedule {matchId, date}`. Nach der Engineantwort wird die lokale
Ausgangsauswahl verworfen und der tatsächliche Kalender neu gelesen. Die Partie
bleibt über ihre gelieferte Identität erkennbar; ursprüngliches und neues Datum
werden nicht aus der Ansichtsgeschichte geraten.
Rücknahmen werden an einem tatsächlich in `scheduling.moved` vorhandenen Termin
angeboten. „Verlegung zurücknehmen“ verlangt ebenfalls eine Bestätigung und
sendet `{action: undo, date}`. Diese Formulierung vermeidet eine erfundene
„letzte“ Aktion: Der Read liefert keine chronologische UI-Aktionshistorie.
Die Engine nimmt die Verlegungen des Vereins an diesem Tag zurück. Auch nach
vollständigem Prozessneustart ist eine angebotene Rücknahme möglich.
Geld, Datum und beide gespeicherten Zufallsgeneratoren bleiben unverändert.
Neue OBS-Dateien erhalten sowohl die Verlegung als auch eine spätere Rücknahme.
Lokal auswählen oder eine Bestätigung abbrechen schreibt nichts. Bei fehlender
Capability ist die Aktion gesperrt. Die getrennte Demo behält ihren bisherigen
unmittelbaren, ausdrücklich fiktiven Planungsweg.
Beobachtung aus der Engineprüfung: Nach der Rücknahme eines konkreten Termins
werden zwei zuvor angebotene Ziele nicht erneut freigegeben. Die UI übernimmt
die aktualisierte Liste und umgeht sie nicht. Der Originalabgleich und die
Bewertung dieses Verhaltens sind als [Engine-Frage #16](https://github.com/Weyoune/openbmh/issues/16)
erfasst; in diesem Paket wurden keine Spielregeln geändert.
Private Screenshots, tatsächliche Eingaben und zugehörige Vorher-/Nachher-OBS:
`bmh_4k_ui/docs/qa/engine-calendar-2026-10-28/`.
## Getrennte Präsentationsdemo
Stand: 24. Oktober 2026, natives Planungspaket. Quelle ist das unveränderte
private HTML-Mockup `bmh_4k_ui`, Referenzrevision
`a7f8e39c8cb562a09d85dabae81e62a981afeb85`; die relevanten Produktdateien
+25 -1
View File
@@ -17,7 +17,7 @@ werden. Die Quelle wird nicht in DemoSource überführt.
## Gebundener Umfang
- `ModernSession::ui_read`: `session`, `desktop`, `camps`, `squad`, `lineup`, `tactics`, `training`, `bank`, `stadium`, `credit`, `environment`, `advertising`, `contracts`. Karriere, Manager,
- `ModernSession::ui_read`: `session`, `desktop`, `camps`, `squad`, `lineup`, `tactics`, `training`, `bank`, `stadium`, `credit`, `environment`, `advertising`, `contracts`, `calendar`, `scheduling`. Karriere, Manager,
Mannschaft, Datum, Saison, Geld, Lagerqualitäten und Angebote kommen aus der
Engine. Katalog und Engine müssen dieselbe Welt-ID und Datenrevision haben.
- Der bestehende RmlUI-Schreibtisch verwendet die gemeinsamen App-Buttons und
@@ -171,6 +171,30 @@ als Regel fest. Neue OBS-Datei und Neustart erhalten den tatsächlichen Vertrag
und die Sperren, ohne einen offenen Quote-Owner zu hinterlassen.
Private Belege: `bmh_4k_ui/docs/qa/engine-contracts-2026-10-28/`.
## Vereinskalender und Spielverlegung
Der [Kalender](../desktop/calendar/README.md) liest den vollständigen Saisonbereich
aus `meta.season.startDate`/`endDate`. Die bestehende Geometrie berechnet nur
Gregorianische Tage/Wochentage; Paarungen, Ereignisse und Status werden aus dem
Read übernommen. Allgemeine Wettbewerbstermine werden nicht als bestätigte
eigene Spiele ausgegeben. Länder-/Ligafilter sind im ersten Vereinsanschluss
lesend; Nationalkalender und Freundschaftsspielplanung bleiben getrennte Pakete.
[Verlegen](../desktop/postpone/README.md) verwendet exakt die `movable`-IDs und
`targetDates` des `scheduling`-Read. Eine eigene Bestätigung sendet
`fixture.reschedule {matchId, date}`. Zielauswahl und abgebrochene Bestätigungen
verändern keine Revision. Die frisch zurückgelesenen Kalender-/Verlegungsdaten
sind danach maßgeblich, nicht eine optimistische Änderung der UI-Tabelle.
Eine explizit angebotene Rücknahme verwendet `{action: undo, date}`. Das Datum
ist der vom Read gemeldete Nachholtermin, nicht ein geratener ursprünglicher
Termin oder eine vermeintlich letzte Aktion. Bestätigte Änderungen bleiben als
neue OBS-Dateien und nach vollständigem Neustart erhalten; eine Rücknahme kann
auch erst nach dem Laden erfolgen. Beide RNGs, Konto und Spielzeit bleiben dabei
unverändert. Der bekannte Verfügbarkeitsbefund nach Undo ist als Engine-Frage #16
erfasst. Die Oberfläche folgt weiterhin den jeweils aktuellen Freigaben.
Private Nachweise: `bmh_4k_ui/docs/qa/engine-calendar-2026-10-28/`.
## Ausführung und Dateien
Laden, Reads nach einer Aktion, Buchen und Speichern laufen seriell über einen
+19 -10
View File
@@ -6,16 +6,18 @@ std::string calendar_date_label(const std::string &iso) {
}
Json App::planning_calendar() const {
if (engine_mode_) return engine_calendar_view();
auto calendar = snap().state.at("calendar");
calendar["league"] = calendar_own_league(*world_, manager(snap()).value("club", ""));
return calendar;
}
std::string App::calendar_day_info(const Json &calendar) const {
if (engine_mode_) return engine_calendar_info(calendar);
const auto days = calendar_days(calendar.at("start").get<std::string>());
const int selected = calendar.at("selected").get<int>();
const auto date = calendar_date_label(days.at(size_t(selected)).iso);
const auto own = manager(snap()).value("club", "");
const auto own = engine_mode_ ? engine_data_.at("desktop").at("meta").at("scope").at("teamId").get<std::string>() : manager(snap()).value("club", "");
for (const auto &f : calendar_fixtures(calendar, *world_, own))
if (f.day == selected) {
const auto *home = world_->find("clubs", f.home), *away = world_->find("clubs", f.away);
@@ -35,9 +37,9 @@ std::string App::calendar_grid(const Json &calendar, double top, double height,
double gap_x, double gap_y, bool booking,
bool postpone) {
const auto days = calendar_days(calendar.at("start").get<std::string>());
const auto own = manager(snap()).value("club", "");
const auto fixtures = calendar_fixtures(calendar, *world_, own);
const bool own_league = calendar.at("league") == calendar_own_league(*world_, own);
const auto own = engine_mode_ ? engine_data_.at("desktop").at("meta").at("scope").at("teamId").get<std::string>() : manager(snap()).value("club", "");
const auto fixtures = engine_mode_ ? std::vector<CalendarFixture>() : calendar_fixtures(calendar, *world_, own);
const bool own_league = !engine_mode_ && calendar.at("league") == calendar_own_league(*world_, own);
const int selected = calendar.at("selected").get<int>();
const double width = (2612 - gap_x * 3) / 4, card_height = (height - gap_y * 2) / 3;
const double grid_top = postpone ? 58 : 66;
@@ -59,15 +61,21 @@ std::string App::calendar_grid(const Json &calendar, double top, double height,
const int day_number = col * 7 + row - offset + 1, index = first + day_number - 1;
if (day_number < 1 || index >= int(days.size()) || days[size_t(index)].month != month) continue;
const auto match = std::find_if(fixtures.begin(), fixtures.end(), [&](const auto &f) { return f.day == index; });
const bool friendly = own_league && std::any_of(calendar.at("friendlies").begin(), calendar.at("friendlies").end(), [&](const auto &f) { return f.at("day") == index; });
const bool occupied = match != fixtures.end() || friendly, chosen = selected == index;
const bool source = postpone && match != fixtures.end() && match->from == calendar.value("source_day", -1);
const auto events = engine_mode_ ? calendar.at("events").value(std::to_string(index), Json{{"kinds",Json::array()},{"ids",Json::array()}}) : Json();
const bool engine_friendly = engine_mode_ && std::find(events.at("kinds").begin(),events.at("kinds").end(),Json("friendly")) != events.at("kinds").end();
const bool friendly = engine_friendly || (own_league && std::any_of(calendar.at("friendlies").begin(), calendar.at("friendlies").end(), [&](const auto &f) { return f.at("day") == index; }));
const bool occupied = engine_mode_ ? !events.at("ids").empty() || friendly : match != fixtures.end() || friendly, chosen = selected == index;
const bool source = engine_mode_ ? postpone && calendar.value("source_day", -1) == index : postpone && match != fixtures.end() && match->from == calendar.value("source_day", -1);
const bool target = engine_mode_ && postpone && std::find(calendar.at("targets").begin(),calendar.at("targets").end(),Json(index)) != calendar.at("targets").end();
const bool moved = engine_mode_ && std::find(calendar.at("moved_days").begin(),calendar.at("moved_days").end(),Json(index)) != calendar.at("moved_days").end();
const bool general = engine_mode_ && !events.at("kinds").empty() && !occupied;
body += btn("calendar-select",
(chosen || source ? "<span class=\"calendar-outline " + std::string(source ? "source-outline" : "") + "\" style=\"" + rect(3, 3, cell_width - 6, cell_height - 6) + "\"></span>" : "") +
(general || target || moved ? "<span class=\"calendar-event-mark\"></span>" : "") +
"<span class=\"control-label\">" + std::to_string(day_number) + "</span>",
std::string("calendar-day ") + (occupied ? "has-match " : "") + (friendly ? "friendly-date " : "") + (source ? "source-day " : "") + (chosen ? "selected-day" : ""),
std::string("calendar-day ") + (occupied ? "has-match " : "") + (friendly ? "friendly-date " : "") + (source ? "source-day " : "") + (target ? "valid-target " : "") + (moved ? "rescheduled-date " : "") + (general ? "competition-date " : "") + (chosen ? "selected-day" : ""),
"id=\"calendar-day-" + std::to_string(index) + "\" data-id=\"" + std::to_string(index) + "\" aria-pressed=\"" + (chosen ? "true" : "false") + "\" aria-label=\"" + calendar_date_label(days[size_t(index)].iso) +
(occupied ? ", belegt" : ", frei") + "\" style=\"" + rect(77 + col * cell_width, grid_top + row * cell_height, cell_width, cell_height) + "\" " + (booking && (index < 7 || occupied) ? "disabled" : ""));
(engine_mode_ ? (occupied ? ", eingetragenes Spiel" : general ? ", Wettbewerbstermin" : ", kein eingetragener Termin") : (occupied ? ", belegt" : ", frei")) + "\" style=\"" + rect(77 + col * cell_width, grid_top + row * cell_height, cell_width, cell_height) + "\" " + (booking && (index < 7 || occupied) ? "disabled" : ""));
}
}
body += "</section>";
@@ -77,7 +85,8 @@ std::string App::calendar_grid(const Json &calendar, double top, double height,
}
std::string App::render_calendar() {
const auto calendar = snap().state.at("calendar");
const auto calendar = engine_mode_ ? engine_calendar_view() : snap().state.at("calendar");
if (engine_mode_) return "<div id=\"report-underlay\" class=\"report-underlay\">" + calendar_grid(calendar,0,1640,28,28,false,false) + "<p id=\"calendar-info\" class=\"calendar-info\">" + esc(calendar_day_info(calendar)) + "</p>" + engine_calendar_footer(calendar) + "</div>";
return "<div id=\"report-underlay\" class=\"report-underlay\">" +
calendar_grid(calendar, 0, 1640, 28, 28, false, false) +
"<p id=\"calendar-info\" class=\"calendar-info\">" + esc(calendar_day_info(calendar)) +
+3
View File
@@ -33,6 +33,9 @@ Json EngineBridge::snapshot() const {
for (const auto *kind : {"session", "desktop", "camps", "squad", "lineup", "tactics", "training", "bank", "stadium", "credit", "environment", "advertising", "contracts"})
bundle[kind] = from_engine(impl_->session->ui_read(cli::Json::Object{{"kind", kind}}, impl_->revision));
validate_engine_desk(bundle);
const auto &season = bundle.at("desktop").at("meta").at("season");
bundle["calendar"] = read({{"kind", "calendar"}, {"from", season.at("startDate")}, {"until", season.at("endDate")}});
bundle["scheduling"] = read({{"kind", "scheduling"}});
return bundle;
}
Json EngineBridge::command(const Json &request) {
+5
View File
@@ -38,6 +38,11 @@ Json engine_contract_request(const Json &bundle, const std::string &player, cons
Json engine_contract_offer(const Json &bundle, const std::string &player, const std::string &quote, int years, int64_t euros, const std::string &request_id);
Json engine_contract_cancel(const Json &bundle, const std::string &quote, const std::string &request_id);
Json engine_calendar_projection(const Json &bundle);
Json engine_scheduling_projection(const Json &bundle);
Json engine_reschedule_command(const Json &bundle, const std::string &match, const std::string &date, const std::string &request_id);
Json engine_reschedule_undo(const Json &bundle, const std::string &date, const std::string &request_id);
// Single-session facade. Its owner serializes all calls on a background worker.
// No RmlUI objects or callbacks cross this boundary.
class EngineBridge {
+101
View File
@@ -0,0 +1,101 @@
// SPDX-License-Identifier: GPL-3.0-only
Json App::engine_calendar_view() const {
auto view = engine_calendar_projection(engine_data_);
view["selected"] = engine_calendar_day_ >= 0 && engine_calendar_day_ < view.at("count").get<int>() ? engine_calendar_day_ : view.at("today").is_number_integer() ? view.at("today").get<int>() : 0;
view["source_day"] = -1; view["targets"] = Json::array(); view["moved_days"] = Json::array();
try {
const auto schedule = engine_scheduling_projection(engine_data_);
for (const auto &row : schedule.at("movable")) if (row.at("id") == engine_move_id_) { view["source_day"] = row.at("day"); view["targets"] = row.at("targets"); }
for (const auto &row : schedule.at("moved")) view["moved_days"].push_back(row.at("day"));
} catch (const std::exception &) {} // a valid calendar also works without scheduling rights
return view;
}
void App::engine_calendar_sync() {
try {
const auto view = engine_calendar_projection(engine_data_);
if (engine_calendar_season_ != view.at("start").get<std::string>() || engine_calendar_day_ < 0 || engine_calendar_day_ >= view.at("count").get<int>()) {
engine_calendar_day_ = view.at("today").is_number_integer() ? view.at("today").get<int>() : 0;
engine_move_id_.clear(); engine_calendar_season_ = view.at("start");
}
if (engine_schedule_pending_ && engine_response_.value("messageType", "") == "command_result") engine_move_id_.clear();
const auto schedule = engine_scheduling_projection(engine_data_);
bool found = false; for (const auto &row : schedule.at("movable")) found |= row.at("id") == engine_move_id_;
if (!found) engine_move_id_.clear();
} catch (const std::exception &) { engine_move_id_.clear(); }
engine_schedule_pending_ = false;
}
std::string App::engine_calendar_info(const Json &view) const {
const int selected = view.at("selected"); const auto days = calendar_days(view.at("start"));
std::string out = calendar_date_label(days.at(size_t(selected)).iso); bool own = false;
for (const auto &f : view.at("fixtures")) if (f.at("day") == selected) {
own = true; out += " · " + std::to_string(f.at("round").get<int>()) + ". Spieltag: " + engine_text(f.at("home").at("name")) + " – " + engine_text(f.at("away").at("name"));
if (!f.at("result").is_null()) out += " " + std::to_string(f.at("result")[0].get<int>()) + ":" + std::to_string(f.at("result")[1].get<int>());
if (f.at("status") == "rescheduled") out += " · verlegt vom " + calendar_date_label(f.at("originalDate"));
else if (f.at("status") == "postponed") out += " · ausgefallen";
else if (f.at("status") == "void") out += " · ohne Ergebnis";
}
if (!own) {
const auto event = view.at("events").value(std::to_string(selected), Json{{"kinds",Json::array()}});
std::set<std::string> labels;
for (const auto &kind : event.at("kinds")) {
const auto k = kind.get<std::string>();
labels.insert(k == "league" ? "Ligatermin" : k == "friendly" ? "Freundschaftsspiel" : k == "replay" ? "Nachholtermin" : k == "indoor" ? "Hallenturnier" : k == "national" ? "Länderspieltermin" : k.starts_with("cup:") ? "Pokaltermin" : "Weiterer Wettbewerbstermin");
}
if (labels.empty()) out += " · keine eingetragenen Termine";
else for (const auto &label : labels) out += " · " + label;
}
return out;
}
std::string App::engine_calendar_footer(const Json &view) {
const auto &team = engine_data_.at("desktop").at("data").at("team");
const auto *nation = world_->find("nations", team.value("nationId", ""));
const auto *league = view.at("league").is_string() ? world_->find("competitions", view.at("league")) : nullptr;
return "<nav class=\"report-footer\">" + btn("engine-calendar-filter", esc(nation ? world_->name(*nation) : "Land nicht verfügbar"), "report-reset engine-calendar-label", "id=\"calendar-country\" disabled style=\"" + rect(0,0,1294,94) + "\"") +
btn("engine-calendar-filter", esc(league ? world_->name(*league) : "Vereinskalender"), "report-reset engine-calendar-label", "id=\"calendar-league\" disabled style=\"" + rect(1318,0,1294,94) + "\"") + "</nav>";
}
std::string App::engine_postpone_view() {
const auto view = engine_calendar_view(), schedule = engine_scheduling_projection(engine_data_);
const Json *source = nullptr, *selected = nullptr; bool undo = false;
for (const auto &row : schedule.at("movable")) {
if (row.at("id") == engine_move_id_) source = &row;
if (row.at("day") == view.at("selected")) selected = &row;
}
for (const auto &row : schedule.at("moved")) undo |= row.at("day") == view.at("selected");
const bool target = source && std::find(source->at("targets").begin(),source->at("targets").end(),view.at("selected")) != source->at("targets").end();
std::string title = "Saison " + engine_data_.at("desktop").at("meta").at("season").at("label").get<std::string>();
auto source_view = view; if (source) source_view["selected"] = source->at("day");
const auto hint = !source ? (schedule.at("movable").empty() ? "Zurzeit ist keine Partie zur Verlegung freigegeben." : "Ein verlegbares Ligaspiel auswählen.") : target ? "Für diese Partie verfügbar." : "Dieser Termin ist für die gewählte Partie nicht verfügbar.";
std::string out = "<div id=\"report-underlay\" class=\"report-underlay postpone-layout\"><header class=\"planning-heading\"><h2>Spielverlegung</h2><p>" + esc(title) + "</p>" + planning_progress(source != nullptr,true) + "</header>" + calendar_grid(view,132,1362,28,22,false,true);
out += "<section class=\"postpone-summary source " + std::string(source ? "selected-source" : "") + "\"><h3>Ausgangsspiel</h3><p>" + esc(source ? engine_calendar_info(source_view) : selected ? engine_calendar_info(view) : "Zuerst eine verlegbare Partie wählen.") + "</p><small>" + std::string(source ? "Grün markierte Ziele sind für diese Partie verfügbar." : "Mit „Ausgangsspiel wählen“ bestätigen.") + "</small>" + (source ? btn("postpone-cancel","×","postpone-cancel","id=\"postpone-cancel\" aria-label=\"Ausgangsspielauswahl aufheben\"") : "") + "</section>";
out += "<section class=\"postpone-summary target\"><h3>Gewählter Termin</h3><p>" + esc(engine_calendar_info(view)) + "</p><small class=\"" + std::string(target ? "valid" : "") + "\">" + hint + "</small></section><nav class=\"planning-footer\">";
out += btn("postpone-source","Ausgangsspiel wählen",{},"id=\"postpone-source\" " + std::string(selected ? "" : "disabled")) + btn("postpone-move","Hierhin verlegen",{},"id=\"postpone-move\" " + std::string(target && schedule.at("allowed") == true ? "" : "disabled")) + btn("postpone-undo","Verlegung zurücknehmen",{},"id=\"postpone-undo\" " + std::string(undo && schedule.at("allowed") == true ? "" : "disabled"));
return out + "</nav></div>";
}
bool App::engine_calendar_action(const std::string &action,Rml::Element *target) {
if (menu_ != "calendar" && menu_ != "postpone") return false;
if (action != "calendar-select" && !action.starts_with("postpone-")) return false;
if (engine_busy_ || !engine_fresh_) return true;
const auto view = engine_calendar_view();
if (action == "calendar-select" && target) {
const int day = target->GetAttribute<int>("data-id",-1);
if (day >= 0 && day < view.at("count").get<int>()) { engine_calendar_day_ = day; focus_after_render_ = target->GetId(); refresh(); } return true;
}
if (action == "postpone-cancel") { engine_move_id_.clear(); focus_after_render_ = "postpone-source"; refresh(); return true; }
const auto schedule = engine_scheduling_projection(engine_data_);
if (action == "postpone-source") {
for (const auto &row : schedule.at("movable")) if (row.at("day") == view.at("selected")) { engine_move_id_ = row.at("id"); focus_after_render_ = "calendar-day-" + std::to_string(engine_calendar_day_); refresh(); break; }
return true;
}
const auto days = calendar_days(view.at("start")); const auto date = days.at(size_t(engine_calendar_day_)).iso;
Json command; std::string question;
if (action == "postpone-move") {
command = engine_reschedule_command(engine_data_,engine_move_id_,date,editor::new_id("request:ui-"));
const Json *row = nullptr; for (const auto &r : schedule.at("movable")) if (r.at("id") == engine_move_id_) row = &r;
if (!row) return true;
question = engine_text(row->at("home").at("name")) + " – " + engine_text(row->at("away").at("name")) + " vom " + calendar_date_label(row->at("date")) + " auf " + calendar_date_label(date) + " verlegen?";
} else if (action == "postpone-undo") {
command = engine_reschedule_undo(engine_data_,date,editor::new_id("request:ui-"));
question = "Verlegungen dieses Vereins am " + calendar_date_label(date) + " zurücknehmen und auf ihre ursprünglichen Termine setzen?";
} else return true;
confirmation(question,[this,command] { engine_schedule_pending_ = true; focus_after_render_ = "calendar-day-" + std::to_string(engine_calendar_day_); engine_finance_submit(command); }); return true;
}
+4 -1
View File
@@ -41,6 +41,7 @@ void App::engine_poll() {
engine_credit_ = engine_data_.value("credit", Json()); engine_credit_edits_ = Json::array();
engine_ticket_bind();
engine_contracts_poll();
engine_calendar_sync();
engine_sports_reset();
const auto &f = engine_data_.at("camps").at("data").at("focus");
engine_focus_ = {{"condition", f.at("condition")}, {"technique", f.at("technique")}, {"play", f.at("play")}};
@@ -170,6 +171,7 @@ void App::engine_event(Rml::Event &event) {
if (action == "popup-confirm") { auto callback = std::move(confirm_); popup_.clear(); dirty_ = true; if (callback) callback(); }
return;
}
if (engine_calendar_action(action, node)) return;
if (contracts_action(action, node)) return;
if (environment_action(action, node)) return;
if (advertising_action(action, node)) return;
@@ -182,6 +184,7 @@ void App::engine_event(Rml::Event &event) {
ticket_->open(node, device_ratio_, price.at("min"), price.at("max")); dirty_ = true;
}
else if (action == "engine-open" && (id == "environment" || id == "advertising")) { menu_ = id; advertising_selected_ = -1; advertising_offer_ = 0; refresh(); }
else if (action == "engine-open" && (id == "calendar" || id == "postpone")) { menu_ = id; engine_move_id_.clear(); engine_calendar_sync(); refresh(); }
else if (action == "engine-open" && id == "contracts") { menu_ = id; engine_contracts_clear(false); contracts_player_.clear(); engine_contract_scroll_ = 0.f; refresh(); }
else if (action == "engine-open" && id == "bank") { bank_view_ = "entrance"; bank_hint_.clear(); menu_ = "bank"; refresh(); }
else if (action == "engine-open" && id == "save") engine_save();
@@ -204,5 +207,5 @@ void App::engine_event(Rml::Event &event) {
}
Json App::engine_snapshot() const {
return {{"mode", engine_mode_}, {"busy", engine_busy_}, {"dirty", engine_dirty_}, {"fresh", engine_fresh_}, {"bundle", engine_data_},
{"response", engine_response_}, {"credit_preview", engine_credit_}, {"credit_edits", engine_credit_edits_}, {"training_draft", engine_training_draft_}, {"tactics_draft", engine_tactics_draft_}, {"player_profile", engine_player_}, {"lineup_selected", lineup_selected_}, {"focus", engine_focus_}, {"selected_camp", engine_camp_}, {"notice", engine_notice_}};
{"response", engine_response_}, {"calendar_day", engine_calendar_day_}, {"move_id", engine_move_id_}, {"credit_preview", engine_credit_}, {"credit_edits", engine_credit_edits_}, {"training_draft", engine_training_draft_}, {"tactics_draft", engine_tactics_draft_}, {"player_profile", engine_player_}, {"lineup_selected", lineup_selected_}, {"focus", engine_focus_}, {"selected_camp", engine_camp_}, {"notice", engine_notice_}};
}
+90
View File
@@ -5,6 +5,8 @@
#include <charconv>
#include <set>
#include <limits>
#include <chrono>
#include "modern/ui/demo_calendar.hpp"
namespace bmh::modern_ui {
namespace {
@@ -569,4 +571,92 @@ Json engine_contract_cancel(const Json &bundle, const std::string &id, const std
require(q.is_object() && q.at("id") == id, "Diese Verhandlung ist nicht mehr geöffnet.");
return sports_command(bundle, "contract.cancel", {{"quoteId", id}}, request_id);
}
namespace {
std::chrono::sys_days calendar_iso_day(const std::string &s) {
require(s.size() == 10 && s[4] == '-' && s[7] == '-', "Ungültiges Kalenderdatum.");
for (size_t i = 0; i < s.size(); ++i) if (i != 4 && i != 7) require(s[i] >= '0' && s[i] <= '9', "Ungültige Datumsziffer.");
const auto d = std::chrono::year_month_day{std::chrono::year(std::stoi(s.substr(0,4))), std::chrono::month(unsigned(std::stoi(s.substr(5,2)))), std::chrono::day(unsigned(std::stoi(s.substr(8,2))))};
require(d.ok(), "Ungültiger Kalendertag."); return std::chrono::sys_days{d};
}
int calendar_index(const Json &view, const Json &date) {
require(date.is_string(), "Kalenderdatum fehlt.");
const auto index = (calendar_iso_day(date.get<std::string>()) - calendar_iso_day(view.at("start"))).count();
require(index >= 0 && index < view.at("count").get<int>(), "Datum liegt außerhalb der angezeigten Saison."); return int(index);
}
bool schedule_permission(const Json &bundle) {
const auto commands = bundle.at("desktop").at("meta").at("scope").value("allowedCommands", Json::array());
return commands.is_array() && std::find(commands.begin(),commands.end(),Json("fixture.reschedule")) != commands.end();
}
}
Json engine_calendar_projection(const Json &bundle) {
validate_engine_desk(bundle);
const auto &meta = bundle.at("desktop").at("meta"), &data = lineup_read(bundle, "calendar");
require(meta.at("scope").at("role") == "club", "Der Vereinskalender ist am National-Schreibtisch nicht verfügbar.");
const auto start = meta.at("season").at("startDate").get<std::string>(), end = meta.at("season").at("endDate").get<std::string>();
const auto days = calendar_days(start); // Gregorian geometry only; no demo fixtures or date rules.
require(!days.empty() && days.back().iso == end && data.at("from") == start && data.at("until") == end, "Unvollständiger Saisonkalender.");
Json view = {{"start",start},{"end",end},{"count",days.size()},{"events",Json::object()},{"fixtures",Json::array()},{"league",nullptr}};
const auto today = (calendar_iso_day(meta.at("date")) - calendar_iso_day(start)).count(); view["today"] = today >= 0 && today < int(days.size()) ? Json(today) : Json();
require(data.at("fixtures").is_array() && data.at("days").is_array(), "Kalenderdaten fehlen.");
const auto own = meta.at("scope").at("teamId"); std::map<std::string,Json> fixtures; std::set<std::string> leagues;
for (const auto &f : data.at("fixtures")) {
const auto id = f.at("id").get<std::string>(); require(!id.empty() && !fixtures.contains(id), "Doppelte Kalenderpartie.");
require(f.at("home").at("id") == own || f.at("away").at("id") == own, "Kalenderpartie gehört einem anderen Verein.");
auto row = f; row["day"] = calendar_index(view,f.at("scheduledDate")); (void)calendar_index(view,f.at("originalDate"));
(void)whole_in_range(f.at("round"),1,10000);
const auto status=f.at("status").get<std::string>();require(status=="scheduled"||status=="played"||status=="rescheduled"||status=="postponed"||status=="void","Unbekannter Spielstatus.");
if(!f.at("result").is_null()) {require(f.at("result").is_array()&&f.at("result").size()==2,"Ungültiges Ergebnis.");for(const auto &v:f.at("result"))(void)whole_in_range(v,0,10000);}
if(f.at("competition").value("kind","")=="league")leagues.insert(f.at("competition").at("id").get<std::string>());
fixtures.emplace(id,row); view["fixtures"].push_back(row);
}
if(leagues.size()==1)view["league"]=*leagues.begin();
std::set<int> seen;
for(const auto &raw:data.at("days")) {
const int index=calendar_index(view,raw.at("date"));require(seen.insert(index).second,"Doppelter Kalendertag.");
(void)whole_in_range(raw.at("seasonDay"),0,366);
require(raw.at("eventKinds").is_array()&&raw.at("fixtureIds").is_array(),"Kalenderereignisse fehlen.");
std::set<std::string> ids;
for(const auto &id:raw.at("fixtureIds")) {require(id.is_string()&&fixtures.contains(id.get<std::string>())&&ids.insert(id.get<std::string>()).second,"Unbekannte oder doppelte Kalenderreferenz.");require(fixtures.at(id.get<std::string>()).at("day")==index,"Partie steht am falschen Datum.");}
for(const auto &kind:raw.at("eventKinds"))require(kind.is_string(),"Ungültiger Kalendertermin.");
view["events"][std::to_string(index)]={{"kinds",raw.at("eventKinds")},{"ids",raw.at("fixtureIds")}};
}
for(const auto &[id,f]:fixtures) {
const auto key=std::to_string(f.at("day").get<int>());
require(view.at("events").contains(key),"Partie ohne Kalendertag.");
const auto &ids=view.at("events").at(key).at("ids");require(std::find(ids.begin(),ids.end(),Json(id))!=ids.end(),"Partie fehlt in den Tagesreferenzen.");
}
return view;
}
Json engine_scheduling_projection(const Json &bundle) {
const auto calendar=engine_calendar_projection(bundle);const auto &data=lineup_read(bundle,"scheduling"),&own=bundle.at("desktop").at("meta").at("scope").at("teamId");
require(data.at("movable").is_array()&&data.at("moved").is_array(),"Verlegungsdaten fehlen.");
Json result={{"movable",Json::array()},{"moved",Json::array()},{"allowed",schedule_permission(bundle)}};std::set<std::string> ids;
for(const auto *key:{"movable","moved"})for(const auto &raw:data.at(key)) {
auto row=raw;row["day"]=calendar_index(calendar,raw.at("date"));
require(raw.at("home").at("id")==own||raw.at("away").at("id")==own,"Verlegung gehört einem anderen Verein.");
(void)whole_in_range(raw.at("round"),1,10000);
bool linked=false;for(const auto &f:calendar.at("fixtures"))linked|=f.at("day")==row.at("day")&&f.at("round")==row.at("round")&&f.at("home").at("id")==row.at("home").at("id")&&f.at("away").at("id")==row.at("away").at("id");
require(linked,"Verlegung ohne passende Kalenderpartie.");
if(std::string(key)=="movable") {
require(raw.at("id").is_string()&&!raw.at("id").get<std::string>().empty()&&ids.insert(raw.at("id").get<std::string>()).second,"Doppelte Verlegungs-ID.");
require(raw.at("targetDates").is_array(),"Zieltermine fehlen.");row["targets"]=Json::array();std::set<int> targets;
for(const auto &date:raw.at("targetDates")) {const int d=calendar_index(calendar,date);require(targets.insert(d).second&&d!=row.at("day"),"Doppelter oder unveränderter Zieltermin.");row["targets"].push_back(d);}
}
result[key].push_back(row);
}
return result;
}
Json engine_reschedule_command(const Json &bundle,const std::string &match,const std::string &date,const std::string &request_id) {
const auto view=engine_scheduling_projection(bundle);bool found=false;
for(const auto &row:view.at("movable"))if(row.at("id")==match)for(const auto &target:row.at("targetDates"))found|=target==date;
require(found,"Partie oder Zieltermin ist nicht mehr verfügbar.");
return sports_command(bundle,"fixture.reschedule",{{"matchId",match},{"date",date}},request_id);
}
Json engine_reschedule_undo(const Json &bundle,const std::string &date,const std::string &request_id) {
const auto view=engine_scheduling_projection(bundle);bool found=false;
for(const auto &row:view.at("moved"))found|=row.at("date")==date;
require(found,"An diesem Termin ist keine Rücknahme verfügbar.");
return sports_command(bundle,"fixture.reschedule",{{"action","undo"},{"date",date}},request_id);
}
} // namespace bmh::modern_ui
+7 -2
View File
@@ -74,6 +74,9 @@ void App::engine_render() {
advertising_available = advertising_available && (std::find(allowed.begin(), allowed.end(), Json("advertising.accept")) != allowed.end() || std::find(allowed.begin(), allowed.end(), Json("budget.commit")) != allowed.end());
bool contracts_available = false;
try { (void)engine_contracts_projection(engine_data_); contracts_available = true; } catch (const std::exception &) {}
bool calendar_available = false, scheduling_available = false;
try { (void)engine_calendar_projection(engine_data_); calendar_available = true; } catch (const std::exception &) {}
try { scheduling_available = engine_scheduling_projection(engine_data_).at("allowed"); } catch (const std::exception &) {}
init_desktop();
for (const auto &[id, o] : desktop_.at("objects").items()) {
if (!o.value("visible", false)) continue;
@@ -106,11 +109,13 @@ void App::engine_render() {
const auto route = id.substr(4);
const bool camp_allowed = desk.at("menuAvailability").at("camps").value("status", "") == "available";
const auto commands = meta.at("scope").value("allowedCommands", Json::array());
const bool supported = (route == "contracts" && contracts_available && engine_fresh_) || (route == "environment" && environment_available && engine_fresh_) || (route == "advertising" && advertising_available && engine_fresh_) || (route == "bank" && bank_available && engine_fresh_) || (route == "training" && training_available && engine_fresh_) || (route == "tactics" && tactics_available && engine_fresh_) || (route == "lineup" && lineup_available && engine_fresh_) || route == "save" || (route == "camp" && engine_fresh_ && camp_allowed && std::find(commands.begin(), commands.end(), Json("camp.book")) != commands.end());
const bool supported = (route == "calendar" && calendar_available && engine_fresh_) || (route == "postpone" && scheduling_available && engine_fresh_) || (route == "contracts" && contracts_available && engine_fresh_) || (route == "environment" && environment_available && engine_fresh_) || (route == "advertising" && advertising_available && engine_fresh_) || (route == "bank" && bank_available && engine_fresh_) || (route == "training" && training_available && engine_fresh_) || (route == "tactics" && tactics_available && engine_fresh_) || (route == "lineup" && lineup_available && engine_fresh_) || route == "save" || (route == "camp" && engine_fresh_ && camp_allowed && std::find(commands.begin(), commands.end(), Json("camp.book")) != commands.end());
out += desktop_button(id, o, "engine-open", supported && !engine_busy_);
}
}
out += "</div>";
if (menu_ == "calendar") out += "<div class=\"fill\" style=\"z-index:100;\">" + window("Kalender", calendar_available ? render_calendar() : "<div class=\"fill center\">Der Saisonkalender ist derzeit nicht verfügbar.</div>") + "</div>";
if (menu_ == "postpone") out += "<div class=\"fill\" style=\"z-index:100;\">" + window("Verlegen", scheduling_available ? render_postpone() : "<div class=\"fill center\">Die Spielverlegung ist derzeit nicht verfügbar.</div>") + "</div>";
if (menu_ == "contracts") out += "<div class=\"fill\" style=\"z-index:100;\">" + window("Verträge", render_contracts()) + "</div>";
if (menu_ == "environment") out += "<div class=\"fill\" style=\"z-index:100;\">" + window("Umfeld", render_environment()) + "</div>";
if (menu_ == "advertising") out += "<div class=\"fill\" style=\"z-index:100;\">" + window("Werbung", render_advertising()) + "</div>";
@@ -120,7 +125,7 @@ void App::engine_render() {
if (menu_ == "lineup") out += "<div class=\"fill\" style=\"z-index:100;\">" + window("Aufstellung", render_lineup()) + "</div>";
if (menu_ == "camp") out += "<div class=\"fill\" style=\"z-index:100;\">" + window("Trainingslager", render_camp()) + "</div>";
}
if ((menu_ == "bank" || menu_ == "environment" || menu_ == "advertising" || menu_ == "contracts") && !amount_ && contracts_dialog_.empty()) out += "<div class=\"panel\" style=\"position:absolute;bottom:12dp;left:700dp;right:700dp;padding:9dp;font-size:25dp;z-index:110;\" id=\"engine-status\">" + esc(engine_busy_ ? engine_operation_ : engine_notice_) + "</div>";
if ((menu_ == "bank" || menu_ == "environment" || menu_ == "advertising" || menu_ == "contracts" || menu_ == "calendar" || menu_ == "postpone") && !amount_ && contracts_dialog_.empty()) out += "<div class=\"panel\" style=\"position:absolute;bottom:12dp;left:700dp;right:700dp;padding:9dp;font-size:25dp;z-index:110;\" id=\"engine-status\">" + esc(engine_busy_ ? engine_operation_ : engine_notice_) + "</div>";
if (menu_.empty() || engine_data_.empty()) out += "<div class=\"panel\" style=\"position:absolute;left:850dp;bottom:24dp;right:100dp;padding:18dp;font-size:27dp;\" id=\"engine-status\">" + esc(engine_busy_ ? engine_operation_ : engine_notice_) + "</div>";
element("canvas")->SetInnerRML(out); ++document_generation_;
scale_chalk_shadow();
+9
View File
@@ -11,6 +11,15 @@
void engine_contracts_poll();
void engine_contracts_clear(bool focus = true);
void engine_contracts_close(bool focus = true);
int engine_calendar_day_ = -1;
std::string engine_move_id_, engine_calendar_season_;
bool engine_schedule_pending_ = false;
Json engine_calendar_view() const;
void engine_calendar_sync();
std::string engine_calendar_info(const Json &) const;
std::string engine_calendar_footer(const Json &);
std::string engine_postpone_view();
bool engine_calendar_action(const std::string &, Rml::Element *);
bool engine_commerce_action(const std::string &, Rml::Element *);
bool engine_bank_action(const std::string &, Rml::Element *);
std::string engine_credit_view();
+1
View File
@@ -12,6 +12,7 @@ std::string App::planning_progress(bool second, bool postpone) {
}
std::string App::render_postpone() {
if (engine_mode_) return engine_postpone_view();
const auto calendar = planning_calendar();
const auto own = manager(snap()).value("club", "");
const auto *league = world_->find("competitions", calendar.at("league"));
+1
View File
@@ -1519,6 +1519,7 @@ public:
#include "modern/ui/engine_finance.inc"
#include "modern/ui/engine_commerce.inc"
#include "modern/ui/engine_contracts.inc"
#include "modern/ui/engine_calendar.inc"
} // namespace
bool is_modern_world(const fs::path &file) {
try {
+17 -1
View File
@@ -9,7 +9,7 @@ using namespace bmh;
using namespace bmh::modern_ui;
int main(int argc, char **argv) {
try {
if (argc != 4 || (std::string(argv[1]) != "inspect" && std::string(argv[1]) != "prepare" && std::string(argv[1]) != "verify" && std::string(argv[1]) != "verify-lineup" && std::string(argv[1]) != "verify-sports" && std::string(argv[1]) != "verify-bank" && std::string(argv[1]) != "verify-commerce" && std::string(argv[1]) != "verify-contracts")) throw std::runtime_error("usage: modern_engine_bridge_probe inspect|prepare|verify|verify-lineup|verify-sports|verify-bank|verify-commerce|verify-contracts <world.obw> <new-output-directory>");
if (argc != 4 || (std::string(argv[1]) != "inspect" && std::string(argv[1]) != "prepare" && std::string(argv[1]) != "verify" && std::string(argv[1]) != "verify-lineup" && std::string(argv[1]) != "verify-sports" && std::string(argv[1]) != "verify-bank" && std::string(argv[1]) != "verify-commerce" && std::string(argv[1]) != "verify-contracts" && std::string(argv[1]) != "verify-calendar")) throw std::runtime_error("usage: modern_engine_bridge_probe inspect|prepare|verify|verify-lineup|verify-sports|verify-bank|verify-commerce|verify-contracts|verify-calendar <world.obw> <new-output-directory>");
const fs::path world = argv[2], out = argv[3]; fs::create_directories(out);
const auto write = [&](const char *file, const Json &j) { editor::write_atomic(out / file, j.dump(2)); };
if (std::string(argv[1]) == "prepare") {
@@ -166,6 +166,22 @@ int main(int argc, char **argv) {
if(!found||!after.at("contracts").at("data").at("quote").is_null())throw std::runtime_error("actual accepted contract wrong or quote retained");
write("saved.json",link->save_copy(out/"contracts.obs"));link.reset();link=EngineBridge::open(world,out/"contracts.obs");auto loaded=link->snapshot();write("loaded.json",loaded);if(loaded.at("contracts").at("data")!=after.at("contracts").at("data"))throw std::runtime_error("contract OBS round trip lost state");
}
if(std::string(argv[1])=="verify-calendar") {
const auto run=[&](const Json &request,const std::string &name){auto response=link->command(request);write((name+"-response.json").c_str(),response);if(response.value("messageType","")!="command_result"||link->command(request)!=response)throw std::runtime_error(response.dump());return response;};
const auto calendar=engine_calendar_projection(before),schedule=engine_scheduling_projection(before);
const Json *chosen=nullptr;for(const auto &r:schedule.at("movable"))if(!r.at("targetDates").empty()){chosen=&r;break;}if(!chosen)throw std::runtime_error("no actual movable fixture");
const auto row=*chosen;const std::string target=row.at("targetDates")[0];write("chosen.json",{{"source",row},{"target",target}});
const auto request=engine_reschedule_command(before,row.at("id"),target,"request:move");run(request,"move");const auto moved=link->snapshot();write("moved.json",moved);
bool found=false;for(const auto &f:moved.at("calendar").at("data").at("fixtures"))if(f.at("round")==row.at("round")&&f.at("home").at("id")==row.at("home").at("id")&&f.at("away").at("id")==row.at("away").at("id"))found=f.at("scheduledDate")==target&&f.at("originalDate")==row.at("date")&&f.at("status")=="rescheduled";
if(!found)throw std::runtime_error("fixture did not actually move");
auto stale=request;stale["requestId"]="request:stale-move";if(link->command(stale).value("code","")!="stale_revision"||link->snapshot()!=moved)throw std::runtime_error("stale move changed state");
const auto after_schedule=engine_scheduling_projection(moved);if(!after_schedule.at("movable").empty()){auto bad=request;bad["requestId"]="request:invalid-target";bad["expectedRevision"]=moved.at("desktop").at("meta").at("stateRevision");bad["payload"]={{"matchId",after_schedule.at("movable")[0].at("id")},{"date",after_schedule.at("movable")[0].at("date")}};const auto rejected=link->command(bad);write("invalid-target.json",rejected);if(rejected.value("messageType","")!="error"||link->snapshot()!=moved)throw std::runtime_error("invalid target changed state");}
write("moved-saved.json",link->save_copy(out/"moved.obs"));link.reset();link=EngineBridge::open(world,out/"moved.obs");const auto loaded=link->snapshot();write("loaded-move.json",loaded);if(loaded.at("calendar").at("data")!=moved.at("calendar").at("data")||loaded.at("scheduling").at("data")!=moved.at("scheduling").at("data"))throw std::runtime_error("move lost in OBS round trip");
run(engine_reschedule_undo(loaded,target,"request:undo"),"undo");const auto undone=link->snapshot();write("undone.json",undone);
if(undone.at("calendar").at("data").at("fixtures")!=before.at("calendar").at("data").at("fixtures")||!undone.at("scheduling").at("data").at("moved").empty()||undone.at("desktop").at("data").at("accounts")!=before.at("desktop").at("data").at("accounts"))throw std::runtime_error("undo did not restore fixture/calendar or changed account");
write("undone-saved.json",link->save_copy(out/"undone.obs"));link.reset();link=EngineBridge::open(world,out/"undone.obs");const auto final=link->snapshot();write("loaded-undo.json",final);if(final.at("calendar").at("data").at("fixtures")!=before.at("calendar").at("data").at("fixtures")||!final.at("scheduling").at("data").at("moved").empty())throw std::runtime_error("undo not persisted");
}
std::cout << "engine bridge " << argv[1] << " passed\n"; return 0;
} catch (const std::exception &e) { std::cerr << e.what() << '\n'; return 1; }
}
+30
View File
@@ -246,6 +246,36 @@ int main() {
rejects([&]{engine_contract_cancel(contracts,"quote:contract-8","r");});
cb=contracts;cb["contracts"]["meta"]["scope"]["managerId"]="foreign";rejects([&]{engine_contracts_projection(cb);});
cb=contract_before;for(auto &[kind,row]:cb.items())row["meta"]["scope"]["allowedCommands"]={"quote.request","contract.offer"};require(!engine_contracts_projection(cb).at("rows")[0].at("can_request").get<bool>(),"quote opened without cancellation capability");
auto cal=fixture();const Json season={{"startDate","2026-07-01"},{"endDate","2027-06-30"}};
for(auto &[kind,row]:cal.items()){row["meta"]["season"]=season;row["meta"]["date"]="2026-07-01";row["meta"]["scope"]["allowedCommands"]={"fixture.reschedule"};}
const auto meta_cal=cal.at("desktop").at("meta");
const Json home={{"id","club:6"},{"name","Actual home"}},away={{"id","club:7"},{"name","Actual away"}};
Json fx={{"id","fixture:real"},{"competition",{{"id","league:real"},{"kind","league"}}},{"round",3},{"scheduledDate","2026-08-05"},{"originalDate","2026-08-05"},{"home",home},{"away",away},{"status","scheduled"},{"result",nullptr}};
const Json event={{"date","2026-08-05"},{"seasonDay",35},{"eventKinds",{"league"}},{"fixtureIds",{"fixture:real"}}};
cal["calendar"]={{"messageType","snapshot"},{"meta",meta_cal},{"data",{{"kind","calendar"},{"from","2026-07-01"},{"until","2027-06-30"},{"days",{event}},{"fixtures",{fx}}}}};
const Json move={{"id","opaque:source-42"},{"date","2026-08-05"},{"round",3},{"home",home},{"away",away},{"targetDates",{"2026-07-21","2027-01-18"}}};
cal["scheduling"]={{"messageType","snapshot"},{"meta",meta_cal},{"data",{{"kind","scheduling"},{"movable",{move}},{"moved",Json::array()}}}};
const auto initial_cal=cal;auto calendar=engine_calendar_projection(cal);
require(calendar.at("count")==365&&calendar.at("today")==0&&calendar.at("fixtures")[0].at("day")==35,"calendar guessed an artificial fixture date");
auto schedule=engine_scheduling_projection(cal);require(schedule.at("movable")[0].at("targets")==Json::array({20,201}),"target date mapping wrong");
const auto move_cmd=engine_reschedule_command(cal,"opaque:source-42","2026-07-21","r");require(move_cmd.at("payload").at("matchId")=="opaque:source-42"&&move_cmd.at("expectedRevision")==meta_cal.at("stateRevision"),"move ID or revision reconstructed");
rejects([&]{engine_reschedule_command(cal,"opaque:source-42","2026-07-22","r");});
rejects([&]{engine_reschedule_command(cal,"invented","2026-07-21","r");});
rejects([&]{engine_reschedule_undo(cal,"2026-08-05","r");});
auto bad_cal=cal;bad_cal["calendar"]["data"]["days"][0]["fixtureIds"]={"ghost"};rejects([&]{engine_calendar_projection(bad_cal);});
bad_cal=cal;bad_cal["calendar"]["data"]["from"]="2026-08-01";rejects([&]{engine_calendar_projection(bad_cal);});
bad_cal=cal;bad_cal["calendar"]["data"]["fixtures"][0]["home"]["id"]="foreign";rejects([&]{engine_calendar_projection(bad_cal);});
bad_cal=cal;bad_cal["scheduling"]["meta"]["scope"]["managerId"]="foreign";rejects([&]{engine_scheduling_projection(bad_cal);});
bad_cal=cal;bad_cal["scheduling"]["data"]["movable"][0]["date"]="2026-08-06";rejects([&]{engine_scheduling_projection(bad_cal);});
bad_cal=cal;for(auto &[kind,row]:bad_cal.items())row["meta"]["scope"]["allowedCommands"]=Json::array();require(!engine_scheduling_projection(bad_cal).at("allowed").get<bool>(),"calendar enables missing permission");rejects([&]{engine_reschedule_command(bad_cal,"opaque:source-42","2026-07-21","r");});
auto moved_cal=cal;auto &moved_data=moved_cal["calendar"]["data"];moved_data["fixtures"][0]["scheduledDate"]="2026-07-21";moved_data["fixtures"][0]["status"]="rescheduled";moved_data["days"][0]["date"]="2026-07-21";moved_data["days"][0]["seasonDay"]=20;
moved_cal["scheduling"]["data"]["movable"]=Json::array();moved_cal["scheduling"]["data"]["moved"]={{{"date","2026-07-21"},{"round",3},{"home",home},{"away",away}}};
require(engine_reschedule_undo(moved_cal,"2026-07-21","r").at("payload").at("date")=="2026-07-21","undo used original or last-guessed date");
require(cal==initial_cal,"calendar projections mutated source");
auto leap=cal;for(auto &[kind,row]:leap.items()){row["meta"]["season"]={{"startDate","2027-07-01"},{"endDate","2028-06-30"}};row["meta"]["date"]="2028-02-29";}
leap["calendar"]["data"]["from"]="2027-07-01";leap["calendar"]["data"]["until"]="2028-06-30";leap["calendar"]["data"]["fixtures"]=Json::array();leap["calendar"]["data"]["days"]={{{"date","2028-02-29"},{"seasonDay",243},{"eventKinds",{"national"}},{"fixtureIds",Json::array()}}};
require(engine_calendar_projection(leap).at("count")==366&&engine_calendar_projection(leap).at("today")==243,"leap day lost in calendar geometry");
std::cout << "engine DTO, exact money, scope and booking tests passed\n";
return 0;
} catch (const std::exception &e) { std::cerr << e.what() << '\n'; return 1; }