Files
Dreierpack-Manager/src/modern/ui/almanac_screens.inc
T

310 lines
21 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// SPDX-License-Identifier: GPL-3.0-only
namespace {
const Json &almanac_field(const Json &object, const char *key) {
static const Json absent;
if (object.is_object()) {
const auto found = object.find(key);
if (found != object.end())
return *found;
}
return absent;
}
std::string almanac_text(const Json &value, const std::string &fallback = "—") {
return value.is_string() && !value.get_ref<const std::string &>().empty()
? value.get<std::string>() : fallback;
}
std::string almanac_name(const Json &person) {
return almanac_text(almanac_field(person, "name"));
}
bool almanac_flag(const Json &object, const char *key) {
const auto &value = almanac_field(object, key);
return value.is_boolean() && value.get<bool>();
}
std::string almanac_number(const Json &value) {
return value.is_number_integer() ? number(value.get<int64_t>()) : "—";
}
std::string almanac_score(const Json &value) {
return value.is_array() && value.size() == 2 &&
value[0].is_number_integer() && value[1].is_number_integer()
? std::to_string(value[0].get<int>()) + " : " +
std::to_string(value[1].get<int>()) : "—";
}
std::optional<std::array<int, 3>> almanac_date_parts(const Json &value) {
if (!value.is_string())
return {};
const auto text = value.get<std::string>();
if (text.size() != 10 || text[4] != '-' || text[7] != '-')
return {};
for (size_t i = 0; i < text.size(); ++i)
if (i != 4 && i != 7 && (text[i] < '0' || text[i] > '9'))
return {};
const std::array<int, 3> date = {std::stoi(text.substr(0, 4)),
std::stoi(text.substr(5, 2)),
std::stoi(text.substr(8, 2))};
if (!std::chrono::year_month_day{std::chrono::year{date[0]},
std::chrono::month{unsigned(date[1])},
std::chrono::day{unsigned(date[2])}}.ok())
return {};
return date;
}
const std::array<const char *, 12> almanac_months = {
"Januar", "Februar", "März", "April", "Mai", "Juni",
"Juli", "August", "September", "Oktober", "November", "Dezember"};
std::string almanac_date_label(const Json &value) {
const auto date = almanac_date_parts(value);
return date ? std::to_string((*date)[2]) + ". " +
almanac_months[size_t((*date)[1] - 1)] + " " +
std::to_string((*date)[0]) : "—";
}
std::string almanac_iso(int year, int month, int day) {
std::ostringstream out;
out << std::setfill('0') << std::setw(4) << year << '-' << std::setw(2)
<< month << '-' << std::setw(2) << day;
return out.str();
}
std::string almanac_position(const Json &player) {
const auto value = almanac_text(almanac_field(player, "position"));
return value == "gk" ? "TW" : value == "def" ? "ABW"
: value == "mid" ? "MIT" : value == "fwd" ? "STU" : value;
}
std::string almanac_competition_label(const Json &record) {
const auto &competition = almanac_field(record, "competition");
return almanac_name(competition) + " · " +
almanac_number(almanac_field(record, "round")) + ". " +
(almanac_text(almanac_field(competition, "type"), "") == "league"
? "Spieltag" : "Runde");
}
bool almanac_phases_known(const Json &result) {
if(!almanac_flag(result,"penalties_played"))return true;
const auto &score=almanac_field(result,"penalties");
return score.is_array()&&score.size()==2&&score[0].is_number_integer()&&score[1].is_number_integer()&&score[0]!=score[1];
}
std::string almanac_event_kind(const std::string &kind) {
if (kind == "goal") return "Tor";
if (kind == "miss") return "Fehlschuss";
if (kind == "yellow") return "Gelbe Karte";
if (kind == "second_yellow") return "Gelb-Rote Karte";
if (kind == "red") return "Rote Karte";
if (kind == "injury") return "Verletzung";
if (kind == "substitution") return "Wechsel";
if (kind == "shootout") return "Elfmeterschießen";
return "Ereignis";
}
} // namespace
std::string App::render_almanac() {
const auto query = [&](const Json &request) -> Json {
try {
return engine_mode_ ? engine_almanac_read(request) : source_ ? source_->read_almanac(request)
: Json{{"ok", false}, {"error", "almanac_unavailable"}};
} catch (const std::exception &) {
return {{"ok", false}, {"error", "almanac_unavailable"}};
}
};
const auto index = query({{"kind", "index"}});
const bool available = almanac_flag(index, "ok");
std::vector<int> years;
const auto &year_values = almanac_field(index, "years");
if (available && year_values.is_array())
for (const auto &value : year_values)
if (value.is_number_integer() && value >= 1 && value <= 9999)
years.push_back(value.get<int>());
std::sort(years.begin(), years.end());
years.erase(std::unique(years.begin(), years.end()), years.end());
const auto reference = engine_mode_ ? engine_data_.at("desktop").at("meta").at("date") : snap().state.at("date");
const auto date = almanac_date_parts(reference);
if (almanac_year_ == 0 ||
std::find(years.begin(), years.end(), almanac_year_) == years.end()) {
almanac_year_ = years.empty() ? (date ? (*date)[0] : 0) : years.back();
almanac_day_.clear();
almanac_match_.clear();
almanac_tab_ = "lineups";
}
if (almanac_tab_ != "lineups" && almanac_tab_ != "events")
almanac_tab_ = "lineups";
if (!almanac_day_.empty()) {
const auto selected = almanac_date_parts(almanac_day_);
if (!selected || (*selected)[0] != almanac_year_) {
almanac_day_.clear();
almanac_match_.clear();
}
}
Json record;
if (!almanac_match_.empty()) {
const auto response = query({{"kind", "match"}, {"id", almanac_match_}});
if (almanac_flag(response, "ok") && almanac_field(response, "match").is_object())
record = response.at("match");
else {
almanac_match_.clear();
almanac_tab_ = "lineups";
}
}
const bool detail = record.is_object(), day_view = !almanac_day_.empty();
const auto title = detail ? almanac_competition_label(record)
: day_view ? almanac_date_label(almanac_day_)
: "Spielarchiv" + (almanac_year_ ? " · " + std::to_string(almanac_year_) : "");
const auto crest_image = [&](const Json &team, double size) {
auto key = almanac_field(team, "crest");
if (engine_mode_ && key.is_null()) if (const auto *club = world_->find("clubs", almanac_text(almanac_field(team,"id"),""))) key=club->value("crest",Json());
return key.is_string() && !key.get_ref<const std::string &>().empty() ? picture(renderer_.crest(key.get<std::string>(), theme_ == "silver"), size, size)
: "<span style=\"display:block;width:" + scalar(size) + "dp;height:" + scalar(size) + "dp;\"></span>";
};
// the archive in three steps: the year as twelve months, the matches of a day, a match report
std::string output = "<div class=\"pg-page almanac\">", footer;
const auto back = [&](const std::string &label) { return pg_button("alm-back", "<span>‹ " + label + "</span>", "", "id=\"alm-back\""); };
const auto heading = [&](double size) { return "<h2 id=\"alm-heading\" class=\"pg-h pg-grow\" tabindex=\"-1\" style=\"tab-index:auto;font-size:" + pg(size) + ";line-height:" + pg(size + 6) + ";\">" + esc(title) + "</h2>"; };
Json day_response;
if (!detail && day_view) {
day_response = query({{"kind", "day"}, {"date", almanac_day_}});
output += "<div class=\"pg-row\">" + back("Jahreskalender") + heading(24) + "</div><div id=\"almanac-underlay\" class=\"pg-panel pg-col pg-grow\" style=\"" + pg_css("gap:0px;padding:8px 14px;") + "\"><div class=\"pg-match-head\">" +
pg_kicker("Heim", "text-align:right;") + "<span class=\"pg-k pg-c\" style=\"flex:none;width:" + pg(160) + ";\">ERGEBNIS</span>" + pg_kicker("Auswärts") + "</div><div id=\"alm-day-list\" class=\"pg-tbody\">";
const auto &matches = almanac_field(day_response, "matches");
if (matches.is_array())
for (const auto &match : matches) {
const auto &result = almanac_field(match, "result");
const auto id = almanac_text(almanac_field(match, "id"), "");
const bool known=almanac_phases_known(result);
const bool penalties = known && almanac_flag(result, "penalties_played"), extra = known && almanac_flag(result, "extra_played");
const auto description = almanac_name(almanac_field(match, "home")) + " " + almanac_score(almanac_field(result, "final")) + " " + almanac_name(almanac_field(match, "away")) + " · Spielbericht öffnen";
output += btn("alm-match",
"<span class=\"pg-match-side home\"><strong>" + esc(almanac_name(almanac_field(match, "home"))) + "</strong>" + crest_image(almanac_field(match, "home"), 54) + "</span><span class=\"pg-match-mid\" style=\"width:" + pg(160) + ";\"><span class=\"pg-score\">" +
esc(almanac_score(almanac_field(result, penalties ? "penalties" : "final"))) + (!known ? " ?" : penalties ? " i. E." : extra ? " n. V." : "") + "</span><small>" + esc(almanac_competition_label(match)) + "</small></span><span class=\"pg-match-side\">" +
crest_image(almanac_field(match, "away"), 54) + "<strong>" + esc(almanac_name(almanac_field(match, "away"))) + "</strong></span>",
"alm-match-row pg-match alm-row", "id=\"alm-match-" + esc(id) + "\" data-id=\"" + esc(id) + "\" aria-label=\"" + esc(description) + "\"");
}
if (!matches.is_array() || matches.empty()) output += "<div class=\"pg-empty\">Keine gespielten Partien an diesem Tag.</div>";
output += "</div></div>";
footer = std::to_string(matches.is_array() ? matches.size() : 0) + " gespielte Partien";
} else if (!detail) {
output += "<div class=\"pg-row\">" + heading(24) + "<span class=\"pg-legend\"><span class=\"pg-legend-item\"><span class=\"pg-legend-mark pm-key own\"></span><span>Gespielte Partien</span></span></span></div><div id=\"almanac-underlay\" class=\"pm-grid alm-grid\">";
Json days = Json::array();
if (available && almanac_year_) {
const auto calendar = query({{"kind", "calendar"}, {"year", almanac_year_}});
if (almanac_flag(calendar, "ok") && almanac_field(calendar, "days").is_array())
days = calendar.at("days");
}
if (almanac_year_ >= 1 && almanac_year_ <= 9999)
for (int month = 1; month <= 12; ++month) {
const auto first = std::chrono::year{almanac_year_} / std::chrono::month{unsigned(month)} / 1;
const int offset = int(std::chrono::weekday{std::chrono::sys_days{first}}.iso_encoding()) - 1;
const int count = int(unsigned(std::chrono::year_month_day{std::chrono::sys_days{std::chrono::year{almanac_year_} / std::chrono::month{unsigned(month)} / std::chrono::last}}.day()));
std::string cells;
for (const char *w : {"MO", "DI", "MI", "DO", "FR", "SA", "SO"}) cells += std::string("<span class=\"pm-cell head\">") + w + "</span>";
for (int blank = 0; blank < offset; ++blank) cells += "<span class=\"pm-cell\"></span>";
for (int day = 1; day <= count; ++day) {
const auto iso = almanac_iso(almanac_year_, month, day);
const auto found = std::find_if(days.begin(), days.end(), [&](const auto &entry) { return almanac_field(entry, "date") == iso; });
const bool played = found != days.end() && almanac_field(*found, "count").is_number_integer() && found->at("count").get<int>() > 0;
if (played)
cells += btn("alm-day", "<span>" + std::to_string(day) + "</span>", "pm-cell day own",
"id=\"alm-day-" + iso + "\" data-id=\"" + iso + "\" aria-label=\"" + esc(almanac_date_label(iso) + ", " + almanac_number(found->at("count")) + " gespielte Partien") + "\"");
else
cells += "<span class=\"pm-cell" + std::string(reference.is_string() && iso > reference.get<std::string>() ? " dim" : "") + "\">" + std::to_string(day) + "</span>";
}
output += "<section class=\"pg-panel pm-month alm-month\"><strong class=\"pm-name\">" + std::string(almanac_months[size_t(month - 1)]) + "</strong><div class=\"pm-cells\">" + cells + "</div></section>";
}
else output += "<div class=\"pg-empty\">Keine gespielten Partien im Archiv.</div>";
output += "</div>";
footer = !available ? std::string("Almanach derzeit nicht verfügbar.") : years.empty() ? std::string("Keine gespielten Partien im Archiv")
: almanac_number(almanac_field(index, "match_count")) + " Partien · " + std::to_string(years.front()) + "–" + std::to_string(years.back());
} else {
const auto &result = almanac_field(record, "result"), &weather = almanac_field(record, "weather");
const bool extra = almanac_flag(result, "extra_played"), penalties = almanac_flag(result, "penalties_played");
const bool known=almanac_phases_known(result);
const auto phase = !known ? std::string("Endstand") : std::string(extra ? "Nach Verlängerung" : "Nach regulärer Spielzeit") + (penalties ? " · Entscheidung i. E." : "");
std::string phases = "Reguläre Zeit: " + almanac_score(almanac_field(result, "regulation"));
if (extra) phases += " · Verlängerung: " + almanac_score(almanac_field(result, "extra"));
if (penalties) phases += " · i. E.: " + almanac_score(almanac_field(result, "penalties"));
if (!known) phases="Spielphasen nicht eindeutig überliefert.";
const auto summary_team = [&](const char *side, bool home) {
const auto &team = almanac_field(record, side), &manager = almanac_field(team, "manager");
const auto text = "<div class=\"pg-grow\" style=\"" + std::string(home ? "text-align:right;" : "") + "\"><strong class=\"pg-h pg-nowrap\" style=\"font-size:" + pg(21) + ";line-height:" + pg(26) + ";\" title=\"" + esc(almanac_name(team)) + "\">" + esc(almanac_name(team)) +
"</strong><span class=\"pg-mut\" style=\"display:block;\">Manager: " + esc(manager.is_null() ? std::string("Computer") : almanac_name(manager)) + "</span></div>";
return "<div class=\"pg-row pg-grow\" style=\"" + pg_css("gap:12px;") + "\">" + (home ? text + crest_image(team, 144) : crest_image(team, 144) + text) + "</div>";
};
output += "<div class=\"pg-row\">" + back("Tagespaarungen") + heading(22) + "<span class=\"pg-mut\">" + esc(almanac_date_label(almanac_field(record, "date"))) + "</span></div><div id=\"almanac-underlay\" class=\"pg-col pg-grow\"><section class=\"pg-panel pg-row\" style=\"" + pg_css("gap:20px;") + "\">" +
summary_team("home", true) + "<div class=\"pg-c\" style=\"flex:none;\"><strong class=\"pg-big\" style=\"font-size:" + pg(46) + ";line-height:" + pg(50) + ";\">" + esc(almanac_score(almanac_field(result, "final"))) + "</strong><span class=\"pg-mut\" style=\"display:block;\">" +
esc(phase) + "</span><span class=\"pg-mut\" style=\"display:block;font-size:" + pg(12) + ";\">" + esc(phases) + "</span></div>" + summary_team("away", false) + "</section><div class=\"pg-row\" style=\"" + pg_css("gap:8px;align-items:stretch;") + "\">" +
pg_stat("Schiedsrichter", "<span style=\"font-size:" + pg(17) + ";\">" + esc(almanac_text(almanac_field(record, "referee"))) + "</span>") + pg_stat("Zuschauer", esc(almanac_number(almanac_field(record, "attendance")))) +
pg_stat("Temperatur", esc(almanac_number(almanac_field(weather, "temperature")) + (almanac_field(weather, "temperature").is_number_integer() ? " °C" : ""))) +
pg_stat("Regen", esc(almanac_number(almanac_field(weather, "rain")) + (almanac_field(weather, "rain").is_number_integer() ? " / 7" : ""))) + "</div><nav class=\"pg-tabs\" role=\"tablist\" aria-label=\"Spielbericht\">";
for (const auto &[key, label] : std::array<std::pair<std::string, std::string>, 2>{{{"lineups", "Aufstellungen"}, {"events", "Ereignisse"}}})
output += btn("alm-tab", "<span>" + label + "</span>", almanac_tab_ == key ? "on" : "",
"id=\"alm-tab-" + key + "\" data-id=\"" + key + "\" role=\"tab\" aria-selected=\"" + (almanac_tab_ == key ? "true" : "false") + "\" aria-controls=\"alm-detail-content\"");
output += "</nav><div id=\"alm-detail-content\" class=\"pg-body\" role=\"tabpanel\" aria-labelledby=\"alm-tab-" + almanac_tab_ + "\" style=\"margin-top:-27dp;\">";
if (almanac_tab_ == "lineups") {
for (const auto *side : {"home", "away"}) {
const auto &team = almanac_field(record, side), &lineup = almanac_field(almanac_field(record, "lineups"), side);
output += "<section class=\"pg-panel pg-col pg-grow\" style=\"" + pg_css("gap:3px;padding:10px 14px;") + "overflow-y:auto;\">" + pg_kicker(almanac_name(team) + " · Startelf");
if (!lineup.is_object()) output += "<div class=\"pg-empty\">Keine Aufstellung überliefert.</div>";
else
for (const auto *part : {"starters", "bench"}) {
const bool starters = std::string_view(part) == "starters";
if (!starters) output += pg_kicker("Bank", "margin-top:6px;");
const auto &players = almanac_field(lineup, part);
if (players.is_array())
for (size_t i = 0; i < players.size(); ++i)
output += "<div class=\"pg-row\" style=\"" + pg_css("gap:8px;") + "height:" + pg(starters ? 19 : 17) + ";\"><strong class=\"pg-rank\">" + std::to_string(i + (starters ? 1 : 12)) + "</strong>" + (almanac_position(players[i]) == "—" ? std::string() : pg_pos(almanac_position(players[i]))) +
"<span class=\"pg-nowrap\" style=\"display:block;font-weight:bold;\" title=\"" + esc(almanac_name(players[i])) + "\">" + esc(almanac_name(players[i])) + "</span></div>";
}
output += "</section>";
}
} else {
std::vector<Json> events;
const auto &source_events = almanac_field(record, "events");
if (source_events.is_array())
for (const auto &event : source_events) events.push_back(event);
std::stable_sort(events.begin(), events.end(), [](const Json &a, const Json &b) {
const auto &am = almanac_field(a, "minute"), &bm = almanac_field(b, "minute");
return (am.is_number_integer() ? am.get<int>() : 0) < (bm.is_number_integer() ? bm.get<int>() : 0);
});
output += "<div class=\"pg-panel pg-grow\" role=\"list\" style=\"" + pg_css("padding:6px 14px;") + "overflow-y:auto;\">";
int kick = 0;
const std::array<const char *, 4> goal_types = {"Spiel", "Elfmeter/Freistoß", "Nachschuss", "Ecke"};
for (const auto &event : events) {
const auto kind = almanac_text(almanac_field(event, "kind"), "");
const auto side = almanac_text(almanac_field(event, "side"), "");
const auto player = almanac_name(almanac_field(event, "player"));
const auto other = almanac_name(almanac_field(event, "other"));
const auto &value = almanac_field(event, "detail");
const int detail_value = value.is_number_integer() ? value.get<int>() : -1;
std::string description = player;
if (kind == "shootout")
description = std::string(detail_value == 1 ? "Treffer" : detail_value == 0 ? "Fehlversuch" : "—") + " · " + player;
else if (kind == "substitution")
description = "Ein: " + player + " · Aus: " + other;
else if (kind == "goal" || kind == "miss")
description = player + " · " + (kind == "miss" ? "Zuspiel" : "Vorlage") + ": " + other + " · " + (detail_value >= 0 && detail_value < 4 ? goal_types[size_t(detail_value)] : "—");
const auto minute = kind == "shootout" ? "i. E. " + std::to_string(++kick) : almanac_number(almanac_field(event, "minute")) + ".";
const std::string mark = kind == "yellow" ? "<span class=\"pg-card-mark yellow\"></span>" : kind == "red" ? "<span class=\"pg-card-mark red\"></span>" : kind == "second_yellow" ? "<span class=\"pg-card-mark yellow\"></span><span class=\"pg-card-mark red\"></span>"
: kind == "goal" ? "<span class=\"alm-ball\"></span>" : std::string();
output += "<div class=\"pg-tr alm-event " + esc(kind) + "\" role=\"listitem\" style=\"height:" + pg(30) + ";\">" + pg_td("<strong>" + esc(minute) + "</strong>", 70, "r") + pg_td(mark, 44, "c", true) +
pg_td((side == "home" || side == "away" ? crest_image(almanac_field(record, side.c_str()), 40) : std::string()), 34, "", true) +
pg_td("<strong>" + almanac_event_kind(kind) + "</strong><span>· " + esc(description) + "</span>", 0, "", true) + "</div>";
}
if (events.empty()) output += "<div class=\"pg-empty\">Keine Ereignisse überliefert.</div>";
output += "</div>";
}
output += "</div></div>";
footer = almanac_competition_label(record) + " · Saison " + almanac_text(almanac_field(record, "season"));
}
output += "<nav class=\"pg-foot\">" + (!detail && !day_view ? report_picker("year", -1, 0) : std::string()) + "<span class=\"pg-sp\"></span>" + pg_status(footer) + "</nav>";
if (report_picker_ == "year")
output += btn("alm-year-cancel", "", "alm-picker-shield", "id=\"alm-year-shield\" aria-label=\"Jahresauswahl schließen\"");
return output + "</div>";
}
bool App::almanac_layout_update() {
if (page_native()) return false; // the page lays itself out
if (auto *history=element("alm-day-list")) if (auto *content=doc_->QuerySelector(".window .content")) {
const float width=content->GetBox().GetSize(Rml::BoxArea::Content).x;
if(std::abs(width-almanac_list_width_)>=.001f) {
almanac_list_width_=width;history->SetProperty("width",scalar(width)+"px");
Rml::ElementList rows;history->QuerySelectorAll(rows,".alm-list-head,.alm-match-row");
for(auto *row:rows)row->SetProperty("width",scalar(width)+"px");
return true;
}
}
return false;
}