Add native OBW editor POC with shared MCP session (by Codex)
This commit is contained in:
1 parent
6e5fa72ed5
commit
bde8b10762
48 files changed
+5614
-1
No files matched your search
@@ -0,0 +1,554 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
#include "editor/session.hpp"
|
||||
#include "content/digest.hpp"
|
||||
#include "editor/images.hpp"
|
||||
#include <algorithm>
|
||||
#include <limits>
|
||||
|
||||
namespace bmh::editor {
|
||||
namespace {
|
||||
bool editable(const std::string &name) {
|
||||
return name == "nations" || name == "competitions" || name == "clubs" || name == "players" || name == "stadiums" ||
|
||||
name == "staff" || name == "assets" || name == "review" || name == "image-edits" || name == "manifest";
|
||||
}
|
||||
Json defaults(const std::string &table, const std::string &name) {
|
||||
auto localized = Json{{"default", name}};
|
||||
if (table == "players")
|
||||
return {{"name", {{"first", ""}, {"last", name}}},
|
||||
{"born", nullptr},
|
||||
{"nationalities", Json::array()},
|
||||
{"positions", Json::array()},
|
||||
{"attributes", Json::object()},
|
||||
{"attribute_set", "unrated@1"}};
|
||||
if (table == "clubs")
|
||||
return {{"name", localized}, {"type", "club"}, {"nation", nullptr}, {"colors", Json::array()}};
|
||||
if (table == "nations")
|
||||
return {{"name", localized}, {"confederation", "other"}, {"playable", false}};
|
||||
if (table == "competitions")
|
||||
return {{"name", localized}, {"type", "league"}, {"nation", nullptr}, {"tier", 1},
|
||||
{"visible", true}, {"members", Json::array()}, {"stages", Json::array()}};
|
||||
if (table == "stadiums")
|
||||
return {{"name", localized}, {"capacity", Json::object()}, {"facilities", Json::object()}};
|
||||
if (table == "staff")
|
||||
return {{"name", localized}, {"role", "referee"}, {"attributes", Json::object()}};
|
||||
return Json::object();
|
||||
}
|
||||
std::string prefix(const std::string &table) {
|
||||
if (table == "nations")
|
||||
return "nation:";
|
||||
if (table == "competitions")
|
||||
return "comp:";
|
||||
if (table == "assets")
|
||||
return "asset:";
|
||||
if (table == "staff")
|
||||
return "staff:";
|
||||
if (table == "image-edits")
|
||||
return "image-edit:";
|
||||
return table.substr(0, table.size() - 1) + ':';
|
||||
}
|
||||
} // namespace
|
||||
World &Session::world() {
|
||||
if (!world_)
|
||||
throw Error("no_world");
|
||||
return *world_;
|
||||
}
|
||||
bool Session::dirty() const { return world_ && state_ != saved_state_; }
|
||||
Json Session::info() const {
|
||||
Json result = world_ ? world_->statistics() : Json{{"title", ""}, {"counts", Json::object()}};
|
||||
result["loaded"] = bool(world_);
|
||||
result["revision"] = revision_;
|
||||
result["dirty"] = dirty();
|
||||
result["can_undo"] = cursor_ > 0;
|
||||
result["can_redo"] = cursor_ < history_.size();
|
||||
result["path"] = utf8(saved_path_);
|
||||
return result;
|
||||
}
|
||||
void Session::replace(World value) {
|
||||
world_ = std::make_unique<World>(std::move(value));
|
||||
history_.clear();
|
||||
cursor_ = 0;
|
||||
++revision_;
|
||||
state_ = next_state_++;
|
||||
saved_state_ = world_->source_path.empty() || world_->imported ? 0 : state_;
|
||||
saved_path_ = world_->source_path.empty() || world_->imported || !fs::is_regular_file(world_->source_path)
|
||||
? fs::path{}
|
||||
: world_->source_path;
|
||||
if (!saved_path_.empty() && fs::is_regular_file(saved_path_)) {
|
||||
saved_time_ = fs::last_write_time(saved_path_);
|
||||
saved_size_ = fs::file_size(saved_path_);
|
||||
}
|
||||
}
|
||||
void Session::frame(const Frame &f, bool forward) {
|
||||
for (const auto &change : f.changes) {
|
||||
auto value = forward ? change.after : change.before;
|
||||
if (change.table == "manifest") {
|
||||
if (value)
|
||||
world().manifest = *value;
|
||||
} else
|
||||
world().change(change.table, change.id, value);
|
||||
}
|
||||
for (const auto &file : f.files)
|
||||
world().store->restore(file.name, forward ? file.after : file.before);
|
||||
state_ = forward ? f.after : f.before;
|
||||
}
|
||||
Json Session::apply(const Json &args, std::vector<FileDelta> files, const std::string &label) {
|
||||
auto &w = world();
|
||||
if (args.contains("expected_revision") && args["expected_revision"].get<uint64_t>() != revision_)
|
||||
throw Error("stale_revision");
|
||||
if (!args.contains("changes") || !args["changes"].is_array() || args["changes"].size() > 5000)
|
||||
throw Error("invalid_change");
|
||||
Frame transaction;
|
||||
transaction.label = label;
|
||||
transaction.files = std::move(files);
|
||||
transaction.before = state_;
|
||||
transaction.after = next_state_;
|
||||
std::map<std::pair<std::string, std::string>, size_t> staged;
|
||||
Json created = Json::array();
|
||||
for (const auto &action : args["changes"]) {
|
||||
const auto name = str(action, "table"), op = str(action, "op", "update");
|
||||
if (!editable(name))
|
||||
throw Error("unknown_table");
|
||||
auto id = str(action, "id");
|
||||
if (op == "create" && id.empty()) {
|
||||
id = new_id(prefix(name) + "editor-");
|
||||
created.push_back(id);
|
||||
}
|
||||
if (name == "manifest")
|
||||
id = "manifest";
|
||||
auto key = std::make_pair(name, id);
|
||||
if (!staged.contains(key)) {
|
||||
const auto *existing = name == "manifest" ? &w.manifest : w.find(name, id);
|
||||
std::optional<Json> before = existing ? std::optional<Json>(*existing) : std::nullopt;
|
||||
staged[key] = transaction.changes.size();
|
||||
transaction.changes.push_back({name, id, before, before});
|
||||
}
|
||||
auto &delta = transaction.changes[staged[key]];
|
||||
if (op == "create") {
|
||||
if (delta.after || name == "manifest")
|
||||
throw Error("duplicate_id");
|
||||
delta.after = defaults(name, str(action, "name"));
|
||||
if (action.contains("data"))
|
||||
delta.after->update(action["data"]);
|
||||
(*delta.after)[name == "assets" ? "key" : "id"] = id;
|
||||
} else if (op == "delete") {
|
||||
if (!delta.after)
|
||||
throw Error("record_missing", {{"table", name}, {"id", id}});
|
||||
if (name == "manifest")
|
||||
throw Error("invalid_change");
|
||||
delta.after.reset();
|
||||
} else if (op == "update") {
|
||||
if (!delta.after)
|
||||
throw Error("record_missing", {{"table", name}, {"id", id}});
|
||||
const auto set = action.value("set", Json::object());
|
||||
if (!set.is_object())
|
||||
throw Error("invalid_change");
|
||||
for (auto it = set.begin(); it != set.end(); ++it) {
|
||||
const auto pointer = it.key();
|
||||
if (pointer.empty() || pointer[0] != '/' || pointer == "/id" || pointer.starts_with("/id/") ||
|
||||
(name == "assets" && pointer == "/key"))
|
||||
throw Error("immutable_id");
|
||||
if (name == "manifest" && pointer != "/title" && !pointer.starts_with("/title/") &&
|
||||
pointer != "/start_date" && pointer != "/currency" && !pointer.starts_with("/currency/") &&
|
||||
pointer != "/languages")
|
||||
throw Error("immutable_id");
|
||||
(*delta.after)[Json::json_pointer(pointer)] = it.value();
|
||||
}
|
||||
for (const auto &field : action.value("unset", Json::array())) {
|
||||
auto pointer = field.get<std::string>();
|
||||
if (pointer.empty() || pointer[0] != '/' || pointer == "/id" || (name == "assets" && pointer == "/key"))
|
||||
throw Error("immutable_id");
|
||||
if (name == "manifest" && pointer != "/title" && !pointer.starts_with("/title/") &&
|
||||
pointer != "/start_date" && pointer != "/currency" && !pointer.starts_with("/currency/") &&
|
||||
pointer != "/languages")
|
||||
throw Error("immutable_id");
|
||||
auto split = pointer.rfind('/');
|
||||
auto parent = Json::json_pointer(pointer.substr(0, split));
|
||||
if (delta.after->contains(parent)) {
|
||||
auto leaf_pointer = Json::json_pointer(pointer);
|
||||
auto &container = (*delta.after)[parent];
|
||||
const auto leaf = leaf_pointer.back();
|
||||
if (container.is_object())
|
||||
container.erase(leaf);
|
||||
else if (container.is_array()) {
|
||||
const auto index = std::stoull(leaf);
|
||||
if (index < container.size())
|
||||
container.erase(container.begin() + std::ptrdiff_t(index));
|
||||
}
|
||||
}
|
||||
}
|
||||
} else
|
||||
throw Error("invalid_change");
|
||||
}
|
||||
transaction.changes.erase(std::remove_if(transaction.changes.begin(), transaction.changes.end(),
|
||||
[](const Delta &d) { return d.before == d.after; }),
|
||||
transaction.changes.end());
|
||||
// Membership is edited once, at the club, and stays consistent in each
|
||||
// affected league. This derived change belongs to the same undo frame.
|
||||
std::map<std::string, Json> memberships;
|
||||
for (const auto &d : transaction.changes)
|
||||
if (d.table == "clubs") {
|
||||
const auto old_league = d.before ? str(*d.before, "competition") : "";
|
||||
const auto new_league = d.after ? str(*d.after, "competition") : "";
|
||||
if (old_league == new_league)
|
||||
continue;
|
||||
for (auto league : {old_league, new_league})
|
||||
if (!league.empty()) {
|
||||
auto *comp = w.find("competitions", league);
|
||||
if (!memberships.contains(league)) {
|
||||
if (comp)
|
||||
memberships[league] = *comp;
|
||||
for (const auto &staged_delta : transaction.changes)
|
||||
if (staged_delta.table == "competitions" && staged_delta.id == league && staged_delta.after)
|
||||
memberships[league] = *staged_delta.after;
|
||||
if (!memberships.contains(league))
|
||||
throw Error("missing_reference");
|
||||
}
|
||||
auto &members = memberships[league]["members"];
|
||||
if (members.is_null())
|
||||
members = Json::array();
|
||||
if (!members.is_array())
|
||||
throw Error("invalid_change");
|
||||
members.erase(std::remove(members.begin(), members.end(), Json(d.id)), members.end());
|
||||
if (league == new_league)
|
||||
members.push_back(d.id);
|
||||
}
|
||||
}
|
||||
for (auto &[id, after] : memberships) {
|
||||
bool found = false;
|
||||
for (auto &d : transaction.changes)
|
||||
if (d.table == "competitions" && d.id == id) {
|
||||
d.after = after;
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
if (!found)
|
||||
transaction.changes.push_back({"competitions", id, *w.find("competitions", id), after});
|
||||
}
|
||||
if (transaction.changes.empty() && transaction.files.empty())
|
||||
return {{"changed", false}, {"revision", revision_}, {"created", created}};
|
||||
try {
|
||||
frame(transaction, true);
|
||||
for (auto &change : transaction.changes)
|
||||
if (!change.after) {
|
||||
auto refs = w.references(change.id);
|
||||
if (!refs.empty()) {
|
||||
Json list = Json::array();
|
||||
for (auto &[table, id] : refs)
|
||||
list.push_back({{"table", table}, {"id", id}});
|
||||
throw Error("record_referenced", {{"references", list}});
|
||||
}
|
||||
}
|
||||
for (const auto &problem : w.validate())
|
||||
if (problem["severity"] == "error")
|
||||
throw Error("validation_failed", {{"diagnostics", w.validate()}});
|
||||
} catch (...) {
|
||||
frame(transaction, false);
|
||||
throw;
|
||||
}
|
||||
history_.resize(cursor_);
|
||||
history_.push_back(std::move(transaction));
|
||||
++cursor_;
|
||||
++next_state_;
|
||||
++revision_;
|
||||
if (history_.size() > 100) {
|
||||
history_.erase(history_.begin());
|
||||
--cursor_;
|
||||
}
|
||||
return {{"changed", true}, {"revision", revision_}, {"created", created}};
|
||||
}
|
||||
Json Session::import_image(const Json &args) {
|
||||
auto &w = world();
|
||||
std::string original, extension, original_name;
|
||||
const auto *existing = w.find("assets", str(args, "key"));
|
||||
if (args.contains("file")) {
|
||||
original = read_file(path(str(args, "file")));
|
||||
extension = folded(utf8(path(str(args, "file")).extension()));
|
||||
original_name = utf8(path(str(args, "file")).filename());
|
||||
} else {
|
||||
if (!existing)
|
||||
throw Error("record_missing");
|
||||
auto source = str(existing->value("x-editor", Json::object()), "original");
|
||||
if (source.empty())
|
||||
source = w.asset_file(str(args, "key"));
|
||||
original = w.store->read(source);
|
||||
extension = folded(utf8(path(source).extension()));
|
||||
original_name = text(existing->value("name", Json(str(args, "key"))));
|
||||
}
|
||||
if (extension != ".png" && extension != ".jpg" && extension != ".jpeg" && extension != ".webp" &&
|
||||
extension != ".svg")
|
||||
throw Error("invalid_image");
|
||||
auto result = images::transform(original, extension, args.value("transform", Json::object()));
|
||||
auto key = str(args, "key");
|
||||
const auto target = args.value("target", Json::object());
|
||||
if (key.empty()) {
|
||||
if (!target.empty()) {
|
||||
auto id = str(target, "id");
|
||||
auto table = str(target, "table");
|
||||
key = "asset:" + table + '/' + id + '/' + str(target, "field", table == "players" ? "photo" : "crest");
|
||||
} else
|
||||
key = new_id("asset:uploaded/");
|
||||
}
|
||||
const auto original_hash = content::sha256(original), edited_hash = content::sha256(result.bytes);
|
||||
auto source_file = "x-editor/originals/" + original_hash + extension;
|
||||
auto output_file = "assets/edited/" + edited_hash + result.extension;
|
||||
std::vector<FileDelta> files;
|
||||
for (auto &[name, data] :
|
||||
std::vector<std::pair<std::string, std::string>>{{source_file, original}, {output_file, result.bytes}}) {
|
||||
if (!w.store->contains(name))
|
||||
files.push_back({name, w.store->overlay(name), std::make_shared<const std::string>(std::move(data))});
|
||||
}
|
||||
Json row{
|
||||
{"key", key},
|
||||
{"name", {{"default", original_name}}},
|
||||
{"files", {{result.extension == ".svg" ? "svg" : "native", output_file}}},
|
||||
{"width", result.width},
|
||||
{"height", result.height},
|
||||
{"source", "user-import"},
|
||||
{"author", "user-supplied"},
|
||||
{"license", "user-supplied"},
|
||||
{"kind", result.extension == ".svg" ? "vector" : "raster"},
|
||||
{"x-editor", {{"original", source_file}, {"original_sha256", original_hash}, {"transform", result.recipe}}}};
|
||||
Json changes = Json::array();
|
||||
if (const auto *before = w.find("assets", key)) {
|
||||
auto after = *before;
|
||||
after.update(row);
|
||||
Json set = Json::object();
|
||||
for (auto it = after.begin(); it != after.end(); ++it)
|
||||
if (it.key() != "key")
|
||||
set['/' + it.key()] = it.value();
|
||||
changes.push_back({{"op", "update"}, {"table", "assets"}, {"id", key}, {"set", set}});
|
||||
} else
|
||||
changes.push_back({{"op", "create"}, {"table", "assets"}, {"id", key}, {"data", row}});
|
||||
if (!target.empty())
|
||||
changes.push_back({{"op", "update"},
|
||||
{"table", str(target, "table")},
|
||||
{"id", str(target, "id")},
|
||||
{"set", {{'/' + str(target, "field", "crest"), key}}}});
|
||||
Json command{{"changes", changes}};
|
||||
if (args.contains("expected_revision"))
|
||||
command["expected_revision"] = args["expected_revision"];
|
||||
auto response = apply(command, std::move(files), "image_import");
|
||||
response["key"] = key;
|
||||
return response;
|
||||
}
|
||||
std::pair<std::string, std::string> Session::asset_bytes(const std::string &key) const {
|
||||
std::lock_guard guard(mutex_);
|
||||
if (!world_)
|
||||
return {images::silhouette(), ".svg"};
|
||||
if (key.starts_with("portrait:")) {
|
||||
const auto *player = world_->find("players", key.substr(9));
|
||||
if (player) {
|
||||
auto photo = world_->asset_file(str(*player, "photo"));
|
||||
if (!photo.empty())
|
||||
return {world_->store->read(photo), utf8(path(photo).extension())};
|
||||
auto recipe = player->value("appearance", Json::object());
|
||||
auto set = str(recipe, "set");
|
||||
const auto file = "assets/portrait-sets/" + set + "/set.json";
|
||||
if (safe_name(file) && world_->store->contains(file)) {
|
||||
const auto parts = Json::parse(world_->store->read(file));
|
||||
int width = parts.value("width", 0), height = parts.value("height", 0);
|
||||
if (width <= 0 || height <= 0 || width > 8192 || height > 8192 ||
|
||||
uint64_t(width) * height > 32ull * 1024 * 1024)
|
||||
throw Error("image_dimensions");
|
||||
images::Raster portrait{width, height, std::vector<uint8_t>(size_t(width) * height * 4)};
|
||||
auto paint = [&](const std::string &asset, int x, int y) {
|
||||
auto input = world_->asset_file(asset);
|
||||
if (input.empty())
|
||||
return;
|
||||
auto layer = images::decode(world_->store->read(input), utf8(path(input).extension()));
|
||||
for (int sy = 0; sy < layer.height; ++sy)
|
||||
for (int sx = 0; sx < layer.width; ++sx) {
|
||||
int dx = x + sx, dy = y + sy;
|
||||
if (dx < 0 || dy < 0 || dx >= width || dy >= height)
|
||||
continue;
|
||||
const auto *src = layer.pixels.data() + (size_t(sy) * layer.width + sx) * 4;
|
||||
auto *dst = portrait.pixels.data() + (size_t(dy) * width + dx) * 4;
|
||||
const unsigned alpha = src[3] * 255u + dst[3] * (255u - src[3]);
|
||||
for (int c = 0; c < 3; ++c)
|
||||
dst[c] =
|
||||
alpha
|
||||
? uint8_t((src[c] * src[3] * 255u + dst[c] * dst[3] * (255u - src[3])) / alpha)
|
||||
: 0;
|
||||
dst[3] = uint8_t((alpha + 127) / 255);
|
||||
}
|
||||
};
|
||||
auto backgrounds = parts.value("backgrounds", Json::array());
|
||||
auto background = recipe.value("background", size_t(0));
|
||||
if (background < backgrounds.size()) {
|
||||
const auto &b = backgrounds[background];
|
||||
paint(str(b, "asset"), b.value("x", 0), b.value("y", 0));
|
||||
}
|
||||
auto layers = parts.value("layers", Json::array()), choices = recipe.value("layers", Json::array());
|
||||
for (size_t i = 0; i < std::min(layers.size(), choices.size()); ++i) {
|
||||
auto options = layers[i].value("parts", Json::array());
|
||||
const auto choice = choices[i].get<size_t>();
|
||||
if (choice < options.size())
|
||||
paint(options[choice].get<std::string>(), layers[i].value("x", 0), layers[i].value("y", 0));
|
||||
}
|
||||
return {images::encode_png(portrait), ".png"};
|
||||
}
|
||||
}
|
||||
return {images::silhouette(), ".svg"};
|
||||
}
|
||||
auto file = key.starts_with("asset:") ? world_->asset_file(key) : key;
|
||||
if (file.empty() || !world_->store->contains(file))
|
||||
return {images::silhouette(), ".svg"};
|
||||
return {world_->store->read(file), utf8(path(file).extension())};
|
||||
}
|
||||
Json Session::execute(const std::string &command, const Json &args) {
|
||||
std::lock_guard guard(mutex_);
|
||||
if (!args.is_object())
|
||||
throw Error("invalid_change");
|
||||
if (args.contains("expected_revision") && args["expected_revision"].get<uint64_t>() != revision_)
|
||||
throw Error("stale_revision");
|
||||
if (command == "info")
|
||||
return info();
|
||||
if (command == "open" || command == "new" || command == "demo") {
|
||||
if (dirty() && !args.value("discard", false))
|
||||
throw Error("unsaved_changes");
|
||||
if (command == "open")
|
||||
replace(World::open(path(str(args, "path")), str(args, "start_date", "2026-07-01")));
|
||||
else
|
||||
replace(command == "demo" ? World::demo() : World::blank(str(args, "title", "Untitled world")));
|
||||
return info();
|
||||
}
|
||||
auto &w = world();
|
||||
if (command == "list")
|
||||
return w.query(args);
|
||||
if (command == "get") {
|
||||
auto name = str(args, "table"), id = str(args, "id");
|
||||
const auto *found = name == "manifest" ? &w.manifest : w.find(name, id);
|
||||
if (!found)
|
||||
throw Error("record_missing");
|
||||
return {{"record", *found}, {"revision", revision_}};
|
||||
}
|
||||
if (command == "rules")
|
||||
return w.rows("rules");
|
||||
if (command == "validate")
|
||||
return {{"diagnostics", w.validate()}, {"revision", revision_}};
|
||||
if (command == "history") {
|
||||
Json values = Json::array();
|
||||
for (size_t i = 0; i < history_.size(); ++i) {
|
||||
Json affected = Json::array();
|
||||
for (auto &delta : history_[i].changes)
|
||||
affected.push_back({{"table", delta.table},
|
||||
{"id", delta.id},
|
||||
{"before", delta.before ? *delta.before : Json()},
|
||||
{"after", delta.after ? *delta.after : Json()}});
|
||||
values.push_back({{"label", history_[i].label}, {"applied", i < cursor_}, {"changes", affected}});
|
||||
}
|
||||
return {{"items", values}, {"revision", revision_}};
|
||||
}
|
||||
if (command == "apply")
|
||||
return apply(args);
|
||||
if (command == "undo" || command == "redo") {
|
||||
if (args.contains("expected_revision") && args["expected_revision"].get<uint64_t>() != revision_)
|
||||
throw Error("stale_revision");
|
||||
if (command == "undo") {
|
||||
if (!cursor_)
|
||||
throw Error("nothing_to_undo");
|
||||
frame(history_[--cursor_], false);
|
||||
} else {
|
||||
if (cursor_ >= history_.size())
|
||||
throw Error("nothing_to_redo");
|
||||
frame(history_[cursor_++], true);
|
||||
}
|
||||
++revision_;
|
||||
return info();
|
||||
}
|
||||
if (command == "save") {
|
||||
const auto destination = args.contains("path") ? path(str(args, "path")) : saved_path_;
|
||||
if (destination.empty())
|
||||
throw Error("output_parent_missing");
|
||||
if (!saved_path_.empty() && fs::absolute(destination) == fs::absolute(saved_path_) &&
|
||||
fs::is_regular_file(saved_path_) &&
|
||||
(fs::last_write_time(saved_path_) != saved_time_ || fs::file_size(saved_path_) != saved_size_))
|
||||
throw Error("source_changed");
|
||||
w.save(destination);
|
||||
saved_path_ = fs::absolute(destination);
|
||||
saved_time_ = fs::last_write_time(saved_path_);
|
||||
saved_size_ = fs::file_size(saved_path_);
|
||||
saved_state_ = state_;
|
||||
return info();
|
||||
}
|
||||
if (command == "roster.move") {
|
||||
auto person = str(args, "player");
|
||||
Json set{{"/team", args.value("team", Json())}};
|
||||
if (args.contains("number"))
|
||||
set["/squad_number"] = args["number"];
|
||||
auto change = Json{{"op", "update"}, {"table", "players"}, {"id", person}, {"set", set}};
|
||||
return apply({{"changes", Json::array({change})}}, {}, "move_player");
|
||||
}
|
||||
if (command == "roster.swap") {
|
||||
auto first = w.find("players", str(args, "first")), second = w.find("players", str(args, "second"));
|
||||
if (!first || !second || first == second)
|
||||
throw Error("invalid_change");
|
||||
Json changes = Json::array();
|
||||
for (auto pair : {std::pair{first, second}, std::pair{second, first}}) {
|
||||
Json set;
|
||||
for (auto field : {"team", "squad_number", "squad_order"})
|
||||
set['/' + std::string(field)] = pair.second->value(field, Json());
|
||||
changes.push_back({{"op", "update"}, {"table", "players"}, {"id", (*pair.first)["id"]}, {"set", set}});
|
||||
}
|
||||
return apply({{"changes", changes}}, {}, "swap_player");
|
||||
}
|
||||
if (command == "roster.order") {
|
||||
auto team = str(args, "team");
|
||||
auto order = args.value("players", Json::array());
|
||||
std::set<std::string> expected, actual;
|
||||
for (auto &row : w.rows("players"))
|
||||
if (str(row, "team") == team)
|
||||
expected.insert(str(row, "id"));
|
||||
for (auto &row : order)
|
||||
actual.insert(row.get<std::string>());
|
||||
if (expected != actual || actual.size() != order.size())
|
||||
throw Error("invalid_change");
|
||||
Json changes = Json::array();
|
||||
for (size_t i = 0; i < order.size(); ++i)
|
||||
changes.push_back(
|
||||
{{"op", "update"}, {"table", "players"}, {"id", order[i]}, {"set", {{"/squad_order", i}}}});
|
||||
return apply({{"changes", changes}}, {}, "roster");
|
||||
}
|
||||
if (command == "review.resolve") {
|
||||
auto record = w.find("review", str(args, "id"));
|
||||
if (!record)
|
||||
throw Error("record_missing");
|
||||
const auto choice = args.value("choice", size_t(0));
|
||||
auto alternatives = record->value("alternatives", Json::array());
|
||||
if (choice >= alternatives.size())
|
||||
throw Error("invalid_change");
|
||||
const auto chosen = alternatives[choice].at("value");
|
||||
Json changes =
|
||||
Json::array({{{"op", "update"},
|
||||
{"table", "review"},
|
||||
{"id", str(args, "id")},
|
||||
{"set", {{"/resolved", true}, {"/selected_index", choice}, {"/chosen_value", chosen}}}}});
|
||||
if (record->contains("entity") && record->contains("field"))
|
||||
changes.push_back({{"op", "update"},
|
||||
{"table", record->value("table", "players")},
|
||||
{"id", (*record)["entity"]},
|
||||
{"set", {{str(*record, "field"), chosen}}}});
|
||||
return apply({{"changes", changes}}, {}, "resolve");
|
||||
}
|
||||
if (command == "asset.import" || command == "asset.edit")
|
||||
return import_image(args);
|
||||
if (command == "asset.preview") {
|
||||
auto [bytes, extension] = asset_bytes(str(args, "key"));
|
||||
auto raster = images::preview(bytes, extension, args.value("transform", Json::object()), 1024);
|
||||
return {{"mimeType", "image/png"},
|
||||
{"data", images::base64(images::encode_png(raster))},
|
||||
{"width", raster.width},
|
||||
{"height", raster.height}};
|
||||
}
|
||||
if (command == "asset.export") {
|
||||
auto [bytes, extension] = asset_bytes(str(args, "key"));
|
||||
auto data = images::encode_png(images::decode(bytes, extension, 2048));
|
||||
auto target = path(str(args, "path"));
|
||||
if (folded(utf8(target.extension())) != ".png")
|
||||
throw Error("invalid_image");
|
||||
write_atomic(target, data);
|
||||
return {{"path", utf8(target)}};
|
||||
}
|
||||
throw Error("invalid_change", {{"command", command}});
|
||||
}
|
||||
} // namespace bmh::editor
|
||||
Reference in new issue
Block a user