coyote/servehelper.cpp

597 lines
24 KiB
C++
Raw Normal View History

2023-11-22 08:39:24 +00:00
#include <memory>
#include <exception>
#include <stdexcept>
#include <FastHash.h>
#include <curl/curl.h>
#include "font_awesome.h"
2023-11-22 08:39:24 +00:00
#include "config.h"
#include "settings.h"
2023-11-23 00:16:56 +00:00
#include "models.h"
2023-11-23 06:05:17 +00:00
#include "timeutils.h"
2023-11-22 08:39:24 +00:00
#include "servehelper.h"
2023-11-22 23:27:44 +00:00
#include "lxb_wrapper.h"
2023-11-29 11:36:52 +00:00
#include "curlu_wrapper.h"
2023-11-22 08:39:24 +00:00
#include "routes/routes.h"
#include "blankie/escape.h"
2023-11-22 08:39:24 +00:00
2023-11-23 00:16:56 +00:00
static inline void preprocess_html(const httplib::Request& req, const std::string& domain_name, const std::vector<Emoji>& emojis, lxb_dom_element_t* element);
2023-11-22 23:27:44 +00:00
static inline void preprocess_link(const httplib::Request& req, const std::string& domain_name, lxb_dom_element_t* element);
2023-11-25 04:22:06 +00:00
static inline bool should_fix_link(lxb_dom_element_t* element, const std::string& element_cls);
2023-12-02 13:50:33 +00:00
static inline void get_text_content(lxb_dom_node_t* node, std::string& out);
2023-11-23 00:16:56 +00:00
static inline lxb_dom_node_t* emojify(lxb_dom_node_t* child, const std::vector<Emoji>& emojis);
static inline std::vector<lxb_dom_node*> emojify(lxb_dom_document_t* document, std::string str, const std::vector<Emoji>& emojis);
struct PostStatus {
const char* icon_html;
Node info_node;
};
static Element serialize_post(const httplib::Request& req, const std::string& server, const Post& post, bool main_post, const std::optional<PostStatus>& post_status, const Post* reblogged = nullptr);
2023-11-23 12:20:49 +00:00
static inline Element serialize_media(const Media& media);
2023-11-24 06:37:26 +00:00
static inline Element serialize_poll(const httplib::Request& req, const Poll& poll);
2023-11-22 23:27:44 +00:00
2023-11-22 08:39:24 +00:00
void serve(const httplib::Request& req, httplib::Response& res, std::string title, Element element, Nodes extra_head) {
using namespace std::string_literals;
std::string css_url = get_origin(req) + "/style.css";
2023-11-23 12:20:49 +00:00
res.set_header("Content-Security-Policy", "default-src 'none'; img-src https:; media-src https:; style-src "s + css_url);
2023-11-22 08:39:24 +00:00
Element head("head", {
Element("meta", {{"charset", "utf-8"}}, {}),
Element("title", {std::move(title)}),
Element("link", {{"rel", "stylesheet"}, {"href", std::move(css_url) + "?v=" + std::to_string(css_hash)}}, {}),
Element("meta", {{"name", "viewport"}, {"content", "width=device-width,initial-scale=1"}}, {})
});
head.nodes.reserve(head.nodes.size() + extra_head.size());
head.nodes.insert(head.nodes.end(), extra_head.begin(), extra_head.end());
std::string html = "<!DOCTYPE html>"s + Element("html", {
std::move(head),
std::move(element)
}).serialize();
uint64_t hash = FastHash(html.data(), html.size(), 0);
res.set_header("ETag", std::string(1, '"') + std::to_string(hash) + '"');
if (should_send_304(req, hash)) {
res.status = 304;
res.set_header("Content-Length", std::to_string(html.size()));
res.set_header("Content-Type", "text/html");
} else {
res.set_content(std::move(html), "text/html");
}
}
void serve_error(const httplib::Request& req, httplib::Response& res,
std::string title, std::optional<std::string> subtitle, std::optional<std::string> info) {
Element error_div("div", {{"class", "error"}}, {
Element("h2", {title})
});
if (subtitle) {
error_div.nodes.push_back(Element("p", {
std::move(*subtitle)
}));
}
if (info) {
error_div.nodes.push_back(Element("pre", {
Element("code", {std::move(*info)})
}));
}
Element body("body", {std::move(error_div)});
serve(req, res, std::move(title), std::move(body));
}
void serve_redirect(const httplib::Request& req, httplib::Response& res, std::string url, bool permanent) {
using namespace std::string_literals;
Element body("body", {
"Redirecting to ",
Element("a", {{"href", url}}, {url}),
""
});
res.set_redirect(url, permanent ? 301 : 302);
serve(req, res, "Redirecting to "s + std::move(url) + "", std::move(body));
}
2023-11-29 11:36:52 +00:00
bool starts_with(const CurlUrl& url, const CurlUrl& base) {
if (strcmp(url.get(CURLUPART_SCHEME).get(), base.get(CURLUPART_SCHEME).get()) != 0) {
return false;
}
if (strcmp(url.get(CURLUPART_HOST).get(), base.get(CURLUPART_HOST).get()) != 0) {
return false;
}
CurlStr url_path = url.get(CURLUPART_PATH);
CurlStr base_path = base.get(CURLUPART_PATH);
size_t base_path_len = strlen(base_path.get());
return memcmp(url_path.get(), base_path.get(), base_path_len) == 0
&& (base_path.get()[base_path_len - 1] == '/' || url_path.get()[base_path_len] == '/' || url_path.get()[base_path_len] == '\0');
2023-11-29 11:36:52 +00:00
}
2023-11-22 08:39:24 +00:00
std::string get_origin(const httplib::Request& req) {
if (req.has_header("X-Canonical-Origin")) {
return req.get_header_value("X-Canonical-Origin");
}
if (config.canonical_origin) {
return *config.canonical_origin;
}
std::string origin = "http://";
if (req.has_header("Host")) {
origin += req.get_header_value("Host");
} else {
origin += config.bind_host;
if (config.bind_port != 80) {
origin += ':' + std::to_string(config.bind_port);
}
}
return origin;
}
std::string proxy_mastodon_url(const httplib::Request& req, const std::string& url_str) {
2023-11-29 11:36:52 +00:00
CurlUrl url;
url.set(CURLUPART_URL, url_str.c_str());
2023-11-22 08:39:24 +00:00
2023-11-29 11:36:52 +00:00
std::string new_url = get_origin(req) + '/' + url.get(CURLUPART_HOST).get() + url.get(CURLUPART_PATH).get();
2023-11-22 08:39:24 +00:00
2023-11-29 11:36:52 +00:00
try {
CurlStr query = url.get(CURLUPART_QUERY);
2023-11-22 08:39:24 +00:00
new_url += '?';
new_url += query.get();
2023-11-29 11:36:52 +00:00
} catch (const CurlUrlException& e) {
if (e.code != CURLUE_NO_QUERY) {
throw;
}
2023-11-22 08:39:24 +00:00
}
2023-11-29 11:36:52 +00:00
try {
CurlStr fragment = url.get(CURLUPART_FRAGMENT);
2023-11-22 08:39:24 +00:00
new_url += '#';
new_url += fragment.get();
2023-11-29 11:36:52 +00:00
} catch (const CurlUrlException& e) {
if (e.code != CURLUE_NO_FRAGMENT) {
throw;
}
2023-11-22 08:39:24 +00:00
}
return new_url;
}
bool should_send_304(const httplib::Request& req, uint64_t hash) {
std::string header = req.get_header_value("If-None-Match");
if (header == "*") {
return true;
}
size_t pos = header.find(std::string(1, '"') + std::to_string(hash) + '"');
return pos != std::string::npos && (pos == 0 || header[pos - 1] != '/');
}
2023-11-22 23:27:44 +00:00
2023-11-23 23:46:47 +00:00
Element serialize_post(const httplib::Request& req, const std::string& server, const Post& post, bool pinned, bool main_post) {
2023-11-23 06:05:17 +00:00
using namespace std::string_literals;
2023-11-23 08:49:27 +00:00
if (post.reblog) {
PostStatus post_status = {
fa_retweet,
preprocess_html(req, post.account.emojis, post.account.display_name + " boosted"),
};
return serialize_post(req, server, *post.reblog, main_post, post_status, &post);
2023-11-23 13:43:55 +00:00
} else if (pinned) {
PostStatus post_status = {
fa_thumbtack,
blankie::html::HTMLString("Pinned post"),
};
2023-11-23 23:46:47 +00:00
return serialize_post(req, server, post, main_post, post_status);
} else if (post.in_reply_to_id && post.in_reply_to_account_id && post.account.id == *post.in_reply_to_account_id) {
PostStatus post_status = {
fa_reply,
preprocess_html(req, post.account.emojis, "Replied to "s + post.account.display_name),
};
2023-11-23 23:46:47 +00:00
return serialize_post(req, server, post, main_post, post_status);
} else {
2023-11-23 23:46:47 +00:00
return serialize_post(req, server, post, main_post, std::nullopt);
2023-11-23 08:58:44 +00:00
}
2023-11-23 06:05:17 +00:00
}
2023-12-02 13:50:33 +00:00
std::string get_text_content(lxb_dom_node_t* child) {
std::string out;
get_text_content(child, out);
if (!out.empty()) {
size_t remove_from = out.size();
while (remove_from && out[remove_from - 1] == '\n') {
remove_from--;
}
// Don't engulf everything, otherwise it crashes
// https://ruby.social/@CoralineAda/109951421922797743
if (out.size() > remove_from && remove_from != 0) {
2023-12-02 13:50:33 +00:00
out.erase(remove_from);
}
}
if (!out.empty()) {
size_t remove_to = 0;
while (out.size() > remove_to && out[remove_to] == '\n') {
remove_to++;
}
// Don't engulf everything, otherwise it crashes
// https://ruby.social/@CoralineAda/109951421922797743
if (out.size() > remove_to) {
out.erase(0, remove_to);
}
2023-12-02 13:50:33 +00:00
}
return out;
}
std::string get_text_content(blankie::html::HTMLString str) {
LXB::HTML::Document document(str.str);
return get_text_content(document.body());
}
2023-11-23 00:16:56 +00:00
blankie::html::HTMLString preprocess_html(const httplib::Request& req, const std::string& domain_name, const std::vector<Emoji>& emojis, const blankie::html::HTMLString& str) {
2023-11-22 23:27:44 +00:00
LXB::HTML::Document document(str.str);
2023-11-23 00:16:56 +00:00
preprocess_html(req, domain_name, emojis, document.body_element());
2023-11-22 23:27:44 +00:00
return blankie::html::HTMLString(document.serialize());
}
blankie::html::HTMLString preprocess_html(const httplib::Request& req, const std::vector<Emoji>& emojis, const std::string& str) {
return preprocess_html(req, "", emojis, blankie::html::HTMLString(blankie::html::escape(str)));
}
2023-11-22 23:27:44 +00:00
2023-11-23 00:16:56 +00:00
static inline void preprocess_html(const httplib::Request& req, const std::string& domain_name, const std::vector<Emoji>& emojis, lxb_dom_element_t* element) {
2023-11-22 23:27:44 +00:00
const char* tag_name = reinterpret_cast<const char*>(lxb_dom_element_tag_name(element, nullptr));
if (strncmp(tag_name, "A", 2) == 0) {
// Proprocess links
preprocess_link(req, domain_name, element);
}
// Walk through the element's children
lxb_dom_node_t* child = lxb_dom_node_first_child(lxb_dom_interface_node(element));
while (child) {
if (child->type == LXB_DOM_NODE_TYPE_ELEMENT) {
2023-11-23 00:16:56 +00:00
preprocess_html(req, domain_name, emojis, lxb_dom_interface_element(child));
} else if (child->type == LXB_DOM_NODE_TYPE_TEXT) {
child = emojify(child, emojis);
2023-11-22 23:27:44 +00:00
}
child = lxb_dom_node_next(child);
}
}
2023-11-23 06:05:17 +00:00
static std::regex mention_class_re("\\bmention\\b");
2023-11-22 23:27:44 +00:00
static inline void preprocess_link(const httplib::Request& req, const std::string& domain_name, lxb_dom_element_t* element) {
using namespace std::string_literals;
size_t href_c_len;
const lxb_char_t* href_c = lxb_dom_element_get_attribute(element, reinterpret_cast<const lxb_char_t*>("href"), 4, &href_c_len);
if (!href_c) {
return;
}
std::string href(reinterpret_cast<const char*>(href_c), href_c_len);
2023-11-23 06:05:17 +00:00
size_t cls_c_len;
const lxb_char_t* cls_c = lxb_dom_element_class(element, &cls_c_len);
std::string cls = cls_c ? std::string(reinterpret_cast<const char*>(cls_c), cls_c_len) : "";
try {
CurlUrl href_url;
href_url.set(CURLUPART_URL, get_origin(req));
href_url.set(CURLUPART_PATH, std::string(href_url.get(CURLUPART_PATH).get()) + req.path);
href_url.set(CURLUPART_URL, href);
CurlUrl instance_url_base;
instance_url_base.set(CURLUPART_SCHEME, "https");
instance_url_base.set(CURLUPART_HOST, domain_name);
// .mention is used in note and posts
// Instance base is used for link fields
if (std::regex_search(cls, mention_class_re) || starts_with(href_url, instance_url_base)) {
// Proxy this instance's URLs to Coyote
href = proxy_mastodon_url(req, std::move(href));
lxb_dom_element_set_attribute(element, reinterpret_cast<const lxb_char_t*>("href"), 4, reinterpret_cast<const lxb_char_t*>(href.data()), href.size());
}
} catch (const CurlUrlException& e) {
// example: <a href=""></a> on eldritch.cafe/about
if (e.code != CURLUE_MALFORMED_INPUT) {
throw;
}
2023-11-22 23:27:44 +00:00
}
2023-11-23 08:49:27 +00:00
if (should_fix_link(element, cls)) {
2023-11-22 23:27:44 +00:00
// Set the content of each <a> to its href
lxb_status_t status = lxb_dom_node_text_content_set(lxb_dom_interface_node(element), reinterpret_cast<const lxb_char_t*>(href.data()), href.size());
if (status != LXB_STATUS_OK) {
throw LXB::Exception(status);
}
}
}
2023-11-23 08:49:27 +00:00
static std::regex unhandled_link_re("\\bunhandled-link\\b");
2023-11-25 04:22:06 +00:00
static inline bool should_fix_link(lxb_dom_element_t* element, const std::string& element_cls) {
2023-11-23 08:49:27 +00:00
// https://vt.social/@LucydiaLuminous/111448085044245037
2023-11-25 04:22:06 +00:00
if (std::regex_search(element_cls, unhandled_link_re)) {
2023-11-23 08:49:27 +00:00
return true;
}
2023-11-22 23:27:44 +00:00
auto expected_element = [](lxb_dom_node_t* node, const char* expected_cls) {
2023-12-02 04:08:41 +00:00
if (!node || node->type != LXB_DOM_NODE_TYPE_ELEMENT) {
2023-11-22 23:27:44 +00:00
return false;
}
lxb_dom_element_t* span = lxb_dom_interface_element(node);
const char* tag_name = reinterpret_cast<const char*>(lxb_dom_element_tag_name(span, nullptr));
if (strncmp(tag_name, "SPAN", 5) != 0) {
return false;
}
const lxb_char_t* cls = lxb_dom_element_get_attribute(span, reinterpret_cast<const lxb_char_t*>("class"), 5, nullptr);
return cls && strcmp(reinterpret_cast<const char*>(cls), expected_cls) == 0;
};
lxb_dom_node_t* child = lxb_dom_node_first_child(lxb_dom_interface_node(element));
if (!expected_element(child, "invisible")) {
return false;
}
child = lxb_dom_node_next(child);
if (!expected_element(child, "ellipsis") && !expected_element(child, "")) {
return false;
}
child = lxb_dom_node_next(child);
if (!expected_element(child, "invisible")) {
return false;
}
child = lxb_dom_node_next(child);
return child == nullptr;
}
2023-11-23 00:16:56 +00:00
2023-12-02 13:50:33 +00:00
static inline void get_text_content(lxb_dom_node_t* node, std::string& out) {
bool is_br = false, is_p = false;
if (node->type == LXB_DOM_NODE_TYPE_TEXT) {
size_t len;
const char* text = reinterpret_cast<const char*>(lxb_dom_node_text_content(node, &len));
2023-11-23 00:16:56 +00:00
2023-12-02 13:50:33 +00:00
out.append(text, len);
} else if (node->type == LXB_DOM_NODE_TYPE_ELEMENT) {
lxb_dom_element_t* element = lxb_dom_interface_element(node);
const char* tag_name = reinterpret_cast<const char*>(lxb_dom_element_tag_name(element, nullptr));
is_p = strncmp(tag_name, "P", 2) == 0;
is_br = strncmp(tag_name, "BR", 3) == 0;
}
if (is_p || is_br) {
out.push_back('\n');
}
lxb_dom_node_t* child = lxb_dom_node_first_child(node);
while (child) {
get_text_content(child, out);
child = lxb_dom_node_next(child);
}
if (is_p) {
out.push_back('\n');
}
}
static inline lxb_dom_node_t* emojify(lxb_dom_node_t* child, const std::vector<Emoji>& emojis) {
std::vector<lxb_dom_node_t*> nodes = emojify(child->owner_document, get_text_content(child), emojis);
lxb_dom_node_insert_after(child, nodes[0]);
lxb_dom_node_destroy(child);
child = nodes[0];
for (size_t i = 1; i < nodes.size(); i++) {
lxb_dom_node_insert_after(child, nodes[i]);
child = nodes[i];
2023-11-23 00:16:56 +00:00
}
return child;
}
static std::regex shortcode_re(":([a-zA-Z0-9_]+):");
static inline std::vector<lxb_dom_node_t*> emojify(lxb_dom_document_t* document, std::string str, const std::vector<Emoji>& emojis) {
std::string buf;
std::smatch sm;
std::vector<lxb_dom_node*> res;
while (std::regex_search(str, sm, shortcode_re)) {
buf += sm.prefix();
std::string group_0 = sm.str(0);
auto emoji = std::find_if(emojis.begin(), emojis.end(), [&](const Emoji& i) { return i.shortcode == sm.str(1); });
if (emoji != emojis.end()) {
res.push_back(lxb_dom_interface_node(lxb_dom_document_create_text_node(document, reinterpret_cast<const lxb_char_t*>(buf.data()), buf.size())));
buf.clear();
2023-11-23 06:05:17 +00:00
lxb_dom_element_t* img = lxb_dom_element_create(document, reinterpret_cast<const lxb_char_t*>("IMG"), 3, nullptr, 0, nullptr, 0, nullptr, 0, false);
2023-11-23 00:16:56 +00:00
lxb_dom_element_set_attribute(img, reinterpret_cast<const lxb_char_t*>("class"), 5, reinterpret_cast<const lxb_char_t*>("custom_emoji"), 12);
lxb_dom_element_set_attribute(img, reinterpret_cast<const lxb_char_t*>("alt"), 3, reinterpret_cast<const lxb_char_t*>(group_0.data()), group_0.size());
lxb_dom_element_set_attribute(img, reinterpret_cast<const lxb_char_t*>("title"), 5, reinterpret_cast<const lxb_char_t*>(group_0.data()), group_0.size());
lxb_dom_element_set_attribute(img, reinterpret_cast<const lxb_char_t*>("src"), 3, reinterpret_cast<const lxb_char_t*>(emoji->url.data()), emoji->url.size());
res.push_back(lxb_dom_interface_node(img));
} else {
buf += group_0;
}
str = sm.suffix();
}
if (!str.empty()) {
buf += std::move(str);
}
if (!buf.empty()) {
res.push_back(lxb_dom_interface_node(lxb_dom_document_create_text_node(document, reinterpret_cast<const lxb_char_t*>(buf.data()), buf.size())));
}
return res;
}
2023-11-23 12:20:49 +00:00
static Element serialize_post(const httplib::Request& req, const std::string& server, const Post& post, bool main_post, const std::optional<PostStatus>& post_status, const Post* reblogged) {
using namespace std::string_literals;
bool user_known = !post.account.id.empty();
bool user_ref_known = !post.account.username.empty() && !post.account.server.empty();
// `reblogged == nullptr` since a malicious server could take down the frontend
// by sending a post that is not a reblog with no account information
std::string post_url = user_known || reblogged == nullptr
? get_origin(req) + '/' + server + "/@" + post.account.acct(false) + '/' + post.id + "#m"
: get_origin(req) + '/' + server + "/@" + reblogged->account.acct(false) + '/' + reblogged->id + "#m";
std::string time_title = post.edited_at < 0
? full_time(post.created_at)
: "Created: "s + full_time(post.created_at) + "\nEdited: " + full_time(post.edited_at);
const char* time_badge = post.edited_at < 0 ? "" : " (edited)";
blankie::html::HTMLString preprocessed_html = preprocess_html(req, server, post.emojis, post.content);
// Workaround for https://vt.social/@a1ba@suya.place/110552480243348878#m
if (preprocessed_html.str.find("<p>") == std::string::npos) {
preprocessed_html.str.reserve(preprocessed_html.str.size() + 3 + 4);
preprocessed_html.str.insert(0, "<p>");
preprocessed_html.str.append("</p>");
}
Element contents("div", {{"class", "post-contents"}}, {std::move(preprocessed_html)});
2023-11-24 06:37:26 +00:00
Element post_attachments("div", {{"class", "post-attachments"}}, {});
post_attachments.nodes.reserve(post.media_attachments.size());
for (const Media& media : post.media_attachments) {
post_attachments.nodes.push_back(serialize_media(media));
}
contents.nodes.push_back(std::move(post_attachments));
2023-11-24 06:37:26 +00:00
if (post.poll) {
contents.nodes.push_back(serialize_poll(req, *post.poll));
}
if (post.sensitive) {
std::string spoiler_text = !post.spoiler_text.empty() ? post.spoiler_text : "See more";
contents = Element("details", {
Element("summary", {preprocess_html(req, post.emojis, std::move(spoiler_text))}),
std::move(contents),
});
if (UserSettings(req).auto_open_cw) {
contents.attributes.push_back({"open", ""});
}
}
Element div("div", {{"class", "post"}}, {
Element("div", {{"class", "post-header"}}, {
user_ref_known ? Element("a", {{"href", get_origin(req) + '/' + server + "/@" + post.account.acct(false)}}, {
!post.account.avatar_static.empty()
? Element("img", {{"class", "post-avatar"}, {"alt", "User profile picture"}, {"loading", "lazy"}, {"src", post.account.avatar_static}}, {})
: Node(""),
Element("span", {
Element("b", {preprocess_html(req, post.account.emojis, post.account.display_name)}),
Element("br"), "@", post.account.acct(),
}),
}) : Element("b", {"Unknown user"}),
Element("a", {{"class", "post-time_header"}, {"href", std::move(post_url)}, {"title", time_title}}, {
Element("time", {{"datetime", to_rfc3339(post.created_at)}}, {relative_time(post.created_at, current_time()), time_badge}),
}),
}),
contents,
});
if (post_status) {
div.nodes.insert(div.nodes.begin(), Element("p", {
blankie::html::HTMLString(post_status->icon_html), " ", post_status->info_node,
}));
}
2023-11-23 23:46:47 +00:00
if (main_post) {
div.attributes = {{"class", "post main_post"}, {"id", "m"}};
}
return div;
}
2023-11-23 12:20:49 +00:00
static inline Element serialize_media(const Media& media) {
Element element = [&]() {
if (media.type == "image") {
return Element("a", {{"href", media.url}}, {
2023-11-25 03:53:34 +00:00
Element("img", {{"loading", "lazy"}, {"src", media.preview_url.value_or(media.url)}}, {}),
2023-11-23 12:20:49 +00:00
});
} else if (media.type == "video") {
Element video("video", {{"controls", ""}, {"src", media.url}}, {});
if (media.preview_url) {
video.attributes.push_back({"poster", *media.preview_url});
}
return video;
} else if (media.type == "audio") {
return Element("audio", {{"controls", ""}, {"src", media.url}}, {});
} else if (media.type == "gifv") {
// https://hachyderm.io/@Impossible_PhD/111444541628207638
Element video("video", {{"controls", ""}, {"loop", ""}, {"muted", ""}, {"autoplay", ""}, {"src", media.url}}, {});
if (media.preview_url) {
video.attributes.push_back({"poster", *media.preview_url});
}
return video;
2023-12-02 13:50:33 +00:00
} else if (media.type == "unknown") {
2023-11-23 12:20:49 +00:00
if (media.remote_url) {
// https://botsin.space/@lina@vt.social/111053598696451525
return Element("a", {{"href", *media.remote_url}}, {"Media is not available from this instance, view externally"});
} else {
return Element("p", {"Media is not available from this instance"});
}
} else {
return Element("p", {"Unsupported media type: ", media.type});
}
}();
if (media.description) {
element.attributes.push_back({"alt", *media.description});
element.attributes.push_back({"title", *media.description});
}
return element;
}
2023-11-24 06:37:26 +00:00
static inline Element serialize_poll(const httplib::Request& req, const Poll& poll) {
2023-12-02 03:17:14 +00:00
using namespace std::string_literals;
uint64_t voters_count = poll.voters_count >= 0 ? static_cast<uint64_t>(poll.voters_count) : poll.votes_count;
2023-11-24 06:37:26 +00:00
Element div("div");
auto pick_form = [](uint64_t count, const char* singular, const char* plural) {
return count == 1 ? singular : plural;
};
div.nodes.reserve(poll.options.size() + 1);
for (const PollOption& option : poll.options) {
std::string percentage = voters_count
? std::to_string(option.votes_count * 100 / voters_count) + '%'
2023-11-24 06:37:26 +00:00
: "0%";
div.nodes.push_back(Element("div", {{"class", "poll-option"}, {"title", std::to_string(option.votes_count) + pick_form(option.votes_count, " vote", " votes")}}, {
Element("b", {{"class", "poll-percentage"}}, {percentage}), " ", preprocess_html(req, poll.emojis, option.title),
Element("object", {{"class", "poll-bar"}, {"width", percentage}}, {}),
}));
}
Element p("p", poll.voters_count >= 0
? std::vector<Node>({std::to_string(voters_count), " ", pick_form(voters_count, "voter", "voters")})
: std::vector<Node>({std::to_string(poll.votes_count), " ", pick_form(poll.votes_count, "vote", "votes")})
);
2023-11-24 06:37:26 +00:00
if (poll.expired) {
2023-12-02 03:17:14 +00:00
p.nodes.push_back(" / ");
p.nodes.push_back(Element("time", {{"datetime", to_rfc3339(poll.expires_at)}, {"title", "Expired on "s + full_time(poll.expires_at)}}, {"Expired"}));
} else if (poll.expires_at >= 0) {
2023-12-02 03:17:14 +00:00
p.nodes.push_back(" / ");
p.nodes.push_back(Element("time", {{"datetime", to_rfc3339(poll.expires_at)}, {"title", full_time(poll.expires_at)}}, {
"Expires in ", relative_time(current_time(), poll.expires_at),
}));
2023-11-24 06:37:26 +00:00
}
div.nodes.push_back(std::move(p));
return div;
}