tdesktop/Telegram/SourceFiles/support/support_templates.cpp

744 lines
18 KiB
C++

/*
This file is part of Telegram Desktop,
the official desktop application for the Telegram messaging service.
For license and copyright information please follow this link:
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
*/
#include "support/support_templates.h"
#include "ui/toast/toast.h"
#include "data/data_session.h"
#include "core/shortcuts.h"
#include "main/main_session.h"
#include <QtNetwork/QNetworkAccessManager>
namespace Support {
namespace details {
namespace {
constexpr auto kQueryLimit = 10;
constexpr auto kWeightStep = 1000;
struct Delta {
std::vector<const TemplatesQuestion*> added;
std::vector<const TemplatesQuestion*> changed;
std::vector<const TemplatesQuestion*> removed;
std::map<QString, QStringList> keys;
explicit operator bool() const {
return !added.empty() || !changed.empty() || !removed.empty();
}
};
bool IsTemplatesFile(const QString &file) {
return file.startsWith(qstr("tl_"), Qt::CaseInsensitive)
&& file.endsWith(qstr(".txt"), Qt::CaseInsensitive);
}
QString NormalizeQuestion(const QString &question) {
auto result = QString();
result.reserve(question.size());
for (const auto &ch : question) {
if (ch.isLetterOrNumber()) {
result.append(ch.toLower());
}
}
return result;
}
QString NormalizeKey(const QString &query) {
return TextUtilities::RemoveAccents(query.trimmed().toLower());
}
struct FileResult {
TemplatesFile result;
QStringList errors;
};
enum class ReadState {
None,
Question,
Keys,
Value,
Url,
};
template <typename StateChange, typename LineCallback>
void ReadByLine(
const QByteArray &blob,
StateChange &&stateChange,
LineCallback &&lineCallback) {
using State = ReadState;
auto state = State::None;
auto hadKeys = false;
auto hadValue = false;
for (const auto &utf : blob.split('\n')) {
const auto line = QString::fromUtf8(utf).trimmed();
const auto match = QRegularExpression(
qsl("^\\{([A-Z_]+)\\}$")
).match(line);
if (match.hasMatch()) {
const auto token = match.captured(1);
if (state == State::Value) {
hadKeys = hadValue = false;
}
const auto newState = [&] {
if (token == qstr("VALUE")) {
return hadValue ? State::None : State::Value;
} else if (token == qstr("KEYS")) {
return hadKeys ? State::None : State::Keys;
} else if (token == qstr("QUESTION")) {
return State::Question;
} else if (token == qstr("URL")) {
return State::Url;
} else {
return State::None;
}
}();
stateChange(state, newState);
state = newState;
lineCallback(state, line, true);
} else {
if (!line.isEmpty()) {
if (state == State::Value) {
hadValue = true;
} else if (state == State::Keys) {
hadKeys = true;
}
}
lineCallback(state, line, false);
}
}
}
template <typename Callback>
QString ReadByLineGetUrl(const QByteArray &blob, Callback &&callback) {
using State = ReadState;
auto url = QString();
auto question = TemplatesQuestion();
const auto call = [&] {
while (question.value.endsWith('\n')) {
question.value.chop(1);
}
return callback(base::take(question));
};
ReadByLine(blob, [&](State was, State now) {
if (was == State::Value) {
call();
}
}, [&](State state, const QString &line, bool stateChangeLine) {
if (stateChangeLine) {
return;
}
switch (state) {
case State::Keys:
if (!line.isEmpty()) {
question.originalKeys.push_back(line);
if (const auto norm = NormalizeKey(line); !norm.isEmpty()) {
question.normalizedKeys.push_back(norm);
}
}
break;
case State::Value:
if (!question.value.isEmpty()) {
question.value += '\n';
}
question.value += line;
break;
case State::Question:
if (question.question.isEmpty()) {
question.question = line;
}
break;
case State::Url:
if (url.isEmpty()) {
url = line;
}
break;
}
});
call();
return url;
}
FileResult ReadFromBlob(const QByteArray &blob) {
auto result = FileResult();
result.result.url = ReadByLineGetUrl(blob, [&](TemplatesQuestion &&q) {
const auto normalized = NormalizeQuestion(q.question);
if (!normalized.isEmpty()) {
result.result.questions.emplace(normalized, std::move(q));
}
});
return result;
}
FileResult ReadFile(const QString &path) {
QFile f(path);
if (!f.open(QIODevice::ReadOnly)) {
auto result = FileResult();
result.errors.push_back(
qsl("Couldn't open '%1' for reading!").arg(path));
return result;
}
const auto blob = f.readAll();
f.close();
return ReadFromBlob(blob);
}
void WriteWithOwnUrlAndKeys(
QIODevice &device,
const QByteArray &blob,
const QString &url,
const Delta &delta) {
device.write("{URL}\n");
device.write(url.toUtf8());
device.write("\n\n");
using State = ReadState;
auto question = QString();
auto normalized = QString();
auto ownKeysWritten = false;
ReadByLine(blob, [&](State was, State now) {
if (was == State::Value) {
question = normalized = QString();
}
}, [&](State state, const QString &line, bool stateChangeLine) {
const auto writeLine = [&] {
device.write(line.toUtf8());
device.write("\n", 1);
};
switch (state) {
case State::Keys:
if (stateChangeLine) {
writeLine();
ownKeysWritten = [&] {
if (normalized.isEmpty()) {
return false;
}
const auto i = delta.keys.find(normalized);
if (i == end(delta.keys)) {
return false;
}
device.write(i->second.join('\n').toUtf8());
device.write("\n", 1);
return true;
}();
} else if (!ownKeysWritten) {
writeLine();
}
break;
case State::Value:
writeLine();
break;
case State::Question:
writeLine();
if (!stateChangeLine && question.isEmpty()) {
question = line;
normalized = NormalizeQuestion(line);
}
break;
case State::Url:
break;
}
});
}
struct FilesResult {
TemplatesData result;
TemplatesIndex index;
QStringList errors;
};
FilesResult ReadFiles(const QString &folder) {
auto result = FilesResult();
const auto files = QDir(folder).entryList(QDir::Files);
for (const auto &path : files) {
if (!IsTemplatesFile(path)) {
continue;
}
auto file = ReadFile(folder + '/' + path);
if (!file.result.url.isEmpty() || !file.result.questions.empty()) {
result.result.files[path] = std::move(file.result);
}
result.errors.append(std::move(file.errors));
}
return result;
}
TemplatesIndex ComputeIndex(const TemplatesData &data) {
using Id = TemplatesIndex::Id;
using Term = TemplatesIndex::Term;
auto uniqueFirst = std::map<QChar, base::flat_set<Id>>();
auto uniqueFull = std::map<Id, base::flat_set<Term>>();
const auto pushString = [&](
const Id &id,
const QString &string,
int weight) {
const auto list = TextUtilities::PrepareSearchWords(string);
for (const auto &word : list) {
uniqueFirst[word[0]].emplace(id);
uniqueFull[id].emplace(std::make_pair(word, weight));
}
};
for (const auto &[path, file] : data.files) {
for (const auto &[normalized, question] : file.questions) {
const auto id = std::make_pair(path, normalized);
for (const auto &key : question.normalizedKeys) {
pushString(id, key, kWeightStep * kWeightStep);
}
pushString(id, question.question, kWeightStep);
pushString(id, question.value, 1);
}
}
auto result = TemplatesIndex();
for (const auto &[ch, unique] : uniqueFirst) {
result.first.emplace(ch, unique | ranges::to_vector);
}
for (const auto &[id, unique] : uniqueFull) {
result.full.emplace(id, unique | ranges::to_vector);
}
return result;
}
void ReplaceFileIndex(
TemplatesIndex &result,
TemplatesIndex &&source,
const QString &path) {
for (auto i = begin(result.full); i != end(result.full);) {
if (i->first.first == path) {
i = result.full.erase(i);
} else {
++i;
}
}
for (auto &[id, list] : source.full) {
result.full.emplace(id, std::move(list));
}
using Id = TemplatesIndex::Id;
for (auto &[ch, list] : result.first) {
auto i = ranges::lower_bound(
list,
std::make_pair(path, QString()));
auto j = std::find_if(i, end(list), [&](const Id &id) {
return id.first != path;
});
list.erase(i, j);
}
for (auto &[ch, list] : source.first) {
auto &to = result.first[ch];
to.insert(
end(to),
std::make_move_iterator(begin(list)),
std::make_move_iterator(end(list)));
ranges::sort(to);
}
}
void MoveKeys(TemplatesFile &to, const TemplatesFile &from) {
const auto &existing = from.questions;
for (auto &[normalized, question] : to.questions) {
if (const auto i = existing.find(normalized); i != end(existing)) {
question.originalKeys = i->second.originalKeys;
question.normalizedKeys = i->second.normalizedKeys;
}
}
}
Delta ComputeDelta(const TemplatesFile &was, const TemplatesFile &now) {
auto result = Delta();
for (const auto &[normalized, question] : now.questions) {
const auto i = was.questions.find(normalized);
if (i == end(was.questions)) {
result.added.push_back(&question);
} else {
result.keys.emplace(normalized, i->second.originalKeys);
if (i->second.value != question.value) {
result.changed.push_back(&question);
}
}
}
for (const auto &[normalized, question] : was.questions) {
if (result.keys.find(normalized) == end(result.keys)) {
result.removed.push_back(&question);
}
}
return result;
}
QString FormatUpdateNotification(const QString &path, const Delta &delta) {
auto result = qsl("Template file '%1' updated!\n\n").arg(path);
if (!delta.added.empty()) {
result += qstr("-------- Added --------\n\n");
for (const auto question : delta.added) {
result += qsl("Q: %1\nK: %2\nA: %3\n\n").arg(
question->question,
question->originalKeys.join(qsl(", ")),
question->value.trimmed());
}
}
if (!delta.changed.empty()) {
result += qstr("-------- Modified --------\n\n");
for (const auto question : delta.changed) {
result += qsl("Q: %1\nA: %2\n\n").arg(
question->question,
question->value.trimmed());
}
}
if (!delta.removed.empty()) {
result += qstr("-------- Removed --------\n\n");
for (const auto question : delta.removed) {
result += qsl("Q: %1\n\n").arg(question->question);
}
}
return result;
}
QString UpdateFile(
const QString &path,
const QByteArray &content,
const QString &url,
const Delta &delta) {
auto result = QString();
const auto full = cWorkingDir() + "TEMPLATES/" + path;
const auto old = full + qstr(".old");
QFile(old).remove();
if (QFile(full).copy(old)) {
result += qsl("(old file saved at '%1')"
).arg(path + qstr(".old"));
QFile f(full);
if (f.open(QIODevice::WriteOnly)) {
WriteWithOwnUrlAndKeys(f, content, url, delta);
} else {
result += qsl("\n\nError: could not open new file '%1'!"
).arg(full);
}
} else {
result += qsl("Error: could not save old file '%1'!"
).arg(old);
}
return result;
}
int CountMaxKeyLength(const TemplatesData &data) {
auto result = 0;
for (const auto &[path, file] : data.files) {
for (const auto &[normalized, question] : file.questions) {
for (const auto &key : question.normalizedKeys) {
accumulate_max(result, key.size());
}
}
}
return result;
}
} // namespace
} // namespace details
using namespace details;
struct Templates::Updates {
QNetworkAccessManager manager;
std::map<QString, QNetworkReply*> requests;
};
Templates::Templates(not_null<Main::Session*> session) : _session(session) {
load();
Shortcuts::Requests(
) | rpl::start_with_next([=](not_null<Shortcuts::Request*> request) {
using Command = Shortcuts::Command;
request->check(
Command::SupportReloadTemplates
) && request->handle([=] {
reload();
return true;
});
}, _lifetime);
}
void Templates::reload() {
_reloadToastSubscription = errors(
) | rpl::start_with_next([=](QStringList errors) {
Ui::Toast::Show(errors.isEmpty()
? "Templates reloaded!"
: ("Errors:\n\n" + errors.join("\n\n")));
});
load();
}
void Templates::load() {
if (_reloadAfterRead) {
return;
} else if (_reading || _updates) {
_reloadAfterRead = true;
return;
}
crl::async([=, guard = _reading.make_guard()]() mutable {
auto result = ReadFiles(cWorkingDir() + "TEMPLATES");
result.index = ComputeIndex(result.result);
crl::on_main(std::move(guard), [
=,
result = std::move(result)
]() mutable {
setData(std::move(result.result));
_index = std::move(result.index);
_errors.fire(std::move(result.errors));
crl::on_main(this, [=] {
if (base::take(_reloadAfterRead)) {
reload();
} else {
update();
}
});
});
});
}
void Templates::setData(TemplatesData &&data) {
_data = std::move(data);
_maxKeyLength = CountMaxKeyLength(_data);
}
void Templates::ensureUpdatesCreated() {
if (_updates) {
return;
}
_updates = std::make_unique<Updates>();
QObject::connect(
&_updates->manager,
&QNetworkAccessManager::finished,
[=](QNetworkReply *reply) { updateRequestFinished(reply); });
}
void Templates::update() {
auto errors = QStringList();
const auto sendRequest = [&](const QString &path, const QString &url) {
ensureUpdatesCreated();
if (_updates->requests.find(path) != end(_updates->requests)) {
return;
}
_updates->requests.emplace(
path,
_updates->manager.get(QNetworkRequest(url)));
};
for (const auto &[path, file] : _data.files) {
if (!file.url.isEmpty()) {
sendRequest(path, file.url);
}
}
}
void Templates::updateRequestFinished(QNetworkReply *reply) {
reply->deleteLater();
const auto path = [&] {
for (const auto &[file, sent] : _updates->requests) {
if (sent == reply) {
return file;
}
}
return QString();
}();
if (path.isEmpty()) {
return;
}
_updates->requests[path] = nullptr;
if (reply->error() != QNetworkReply::NoError) {
const auto message = qsl(
"Error: template update failed, url '%1', error %2, %3"
).arg(reply->url().toDisplayString()
).arg(reply->error()
).arg(reply->errorString());
_session->data().serviceNotification({ message });
return;
}
LOG(("Got template from url '%1'"
).arg(reply->url().toDisplayString()));
const auto content = reply->readAll();
crl::async([=, weak = base::make_weak(this)]{
auto result = ReadFromBlob(content);
auto one = TemplatesData();
one.files.emplace(path, std::move(result.result));
auto index = ComputeIndex(one);
crl::on_main(weak,[
=,
one = std::move(one),
errors = std::move(result.errors),
index = std::move(index)
]() mutable {
auto &existing = _data.files.at(path);
auto &parsed = one.files.at(path);
MoveKeys(parsed, existing);
ReplaceFileIndex(_index, ComputeIndex(one), path);
if (!errors.isEmpty()) {
_errors.fire(std::move(errors));
}
if (const auto delta = ComputeDelta(existing, parsed)) {
const auto text = FormatUpdateNotification(
path,
delta);
const auto copy = UpdateFile(
path,
content,
existing.url,
delta);
const auto full = text + copy;
_session->data().serviceNotification({ full });
}
_data.files.at(path) = std::move(one.files.at(path));
_updates->requests.erase(path);
checkUpdateFinished();
});
});
}
void Templates::checkUpdateFinished() {
if (!_updates || !_updates->requests.empty()) {
return;
}
_updates = nullptr;
if (base::take(_reloadAfterRead)) {
reload();
}
}
auto Templates::matchExact(QString query) const
-> std::optional<QuestionByKey> {
if (query.isEmpty() || query.size() > _maxKeyLength) {
return {};
}
query = NormalizeKey(query);
for (const auto &[path, file] : _data.files) {
for (const auto &[normalized, question] : file.questions) {
for (const auto &key : question.normalizedKeys) {
if (key == query) {
return QuestionByKey{ question, key };
}
}
}
}
return {};
}
auto Templates::matchFromEnd(QString query) const
-> std::optional<QuestionByKey> {
if (query.size() > _maxKeyLength) {
query = query.mid(query.size() - _maxKeyLength);
}
const auto size = query.size();
auto queries = std::vector<QString>();
queries.reserve(size);
for (auto i = 0; i != size; ++i) {
queries.push_back(NormalizeKey(query.mid(size - i - 1)));
}
auto result = std::optional<QuestionByKey>();
for (const auto &[path, file] : _data.files) {
for (const auto &[normalized, question] : file.questions) {
for (const auto &key : question.normalizedKeys) {
if (key.size() <= queries.size()
&& queries[key.size() - 1] == key
&& (!result || result->key.size() <= key.size())) {
result = QuestionByKey{ question, key };
}
}
}
}
return result;
}
Templates::~Templates() = default;
auto Templates::query(const QString &text) const -> std::vector<Question> {
const auto words = TextUtilities::PrepareSearchWords(text);
const auto questions = [&](const QString &word) {
const auto i = _index.first.find(word[0]);
return (i == end(_index.first)) ? 0 : i->second.size();
};
const auto best = ranges::min_element(words, std::less<>(), questions);
if (best == std::end(words)) {
return {};
}
const auto narrowed = _index.first.find((*best)[0]);
if (narrowed == end(_index.first)) {
return {};
}
using Id = TemplatesIndex::Id;
using Term = TemplatesIndex::Term;
const auto questionById = [&](const Id &id) {
return _data.files.at(id.first).questions.at(id.second);
};
const auto computeWeight = [&](const Id &id) {
auto result = 0;
const auto full = _index.full.find(id);
for (const auto &word : words) {
const auto from = ranges::lower_bound(
full->second,
word,
std::less<>(),
[](const Term &term) { return term.first; });
const auto till = std::find_if(
from,
end(full->second),
[&](const Term &term) {
return !term.first.startsWith(word);
});
const auto weight = std::max_element(
from,
till,
[](const Term &a, const Term &b) {
return a.second < b.second;
});
if (weight == till) {
return 0;
}
result += weight->second * (weight->first == word ? 2 : 1);
}
return result;
};
using Pair = std::pair<Id, int>;
const auto pairById = [&](const Id &id) {
return std::make_pair(id, computeWeight(id));
};
const auto sorter = [](const Pair &a, const Pair &b) {
// weight DESC filename DESC question ASC
if (a.second > b.second) {
return true;
} else if (a.second < b.second) {
return false;
} else if (a.first.first > b.first.first) {
return true;
} else if (a.first.first < b.first.first) {
return false;
} else {
return (a.first.second < b.first.second);
}
};
const auto good = narrowed->second | ranges::views::transform(
pairById
) | ranges::views::filter([](const Pair &pair) {
return pair.second > 0;
}) | ranges::to_vector | ranges::actions::stable_sort(sorter);
return good | ranges::views::transform([&](const Pair &pair) {
return questionById(pair.first);
}) | ranges::views::take(kQueryLimit) | ranges::to_vector;
}
} // namespace Support