2023-04-23 19:13:49 +02:00
|
|
|
#include "runemanager.h"
|
|
|
|
#include "ui_runemanager.h"
|
|
|
|
|
|
|
|
#include <QDebug>
|
|
|
|
#include <QListWidgetItem>
|
2023-05-01 01:23:08 +02:00
|
|
|
#include <QTimer>
|
2023-04-23 19:13:49 +02:00
|
|
|
|
|
|
|
#include "clientapi.h"
|
|
|
|
|
|
|
|
RuneManager::RuneManager(QWidget* parent) : QWidget(parent), ui(new Ui::RuneManager) {
|
|
|
|
ui->setupUi(this);
|
|
|
|
|
2023-05-01 22:36:11 +02:00
|
|
|
ui->listClientRunes->setIsClient(true);
|
|
|
|
ui->listaaRunes->setIsClient(false);
|
2023-04-23 19:13:49 +02:00
|
|
|
ui->listClientRunes->setOther(ui->listaaRunes);
|
|
|
|
ui->listaaRunes->setOther(ui->listClientRunes);
|
|
|
|
|
2023-04-23 23:54:09 +02:00
|
|
|
QObject::connect(ui->listaaRunes, &RunePageList::runepageChanged, this, &RuneManager::saveRunePageAA);
|
2023-04-30 16:20:13 +02:00
|
|
|
QObject::connect(ui->listClientRunes, &RunePageList::runepageChanged, this, &RuneManager::saveRunePageClient);
|
|
|
|
|
|
|
|
QObject::connect(ui->listaaRunes, &RunePageList::runepageDeleted, this, &RuneManager::deleteRunepageAA);
|
|
|
|
QObject::connect(ui->listClientRunes, &RunePageList::runepageDeleted, this, &RuneManager::deleteRunepageClient);
|
2023-04-23 23:54:09 +02:00
|
|
|
|
2023-04-30 22:10:21 +02:00
|
|
|
QObject::connect(ui->chkAutoCopy, &QCheckBox::clicked, this, &RuneManager::autoSyncToggled);
|
|
|
|
|
2023-05-01 01:23:08 +02:00
|
|
|
|
|
|
|
initialLoadTimer = new QTimer(this);
|
|
|
|
QObject::connect(initialLoadTimer, &QTimer::timeout, this, &RuneManager::loadRunes);
|
|
|
|
initialLoadTimer->setInterval(std::chrono::milliseconds(1));
|
|
|
|
initialLoadTimer->setSingleShot(true);
|
|
|
|
initialLoadTimer->start();
|
2023-04-23 19:13:49 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
RuneManager::~RuneManager() {
|
|
|
|
delete this->ui;
|
|
|
|
}
|
|
|
|
|
2023-04-23 23:54:09 +02:00
|
|
|
void RuneManager::setConfig(Config& config) {
|
|
|
|
this->config = &config;
|
2023-04-30 22:10:21 +02:00
|
|
|
Config::GeneralRunePageConfig& rpc = config.getConfig().runepagesConfig;
|
|
|
|
ui->listaaRunes->loadRunePages(rpc.runePages);
|
|
|
|
ui->chkAutoCopy->setChecked(rpc.autoSync);
|
|
|
|
|
|
|
|
if(rpc.autoSync) {
|
|
|
|
syncRunes();
|
|
|
|
}
|
2023-04-23 23:54:09 +02:00
|
|
|
}
|
|
|
|
|
2023-05-01 01:23:08 +02:00
|
|
|
void RuneManager::setDataDragon(DataDragon& dd) {
|
|
|
|
ui->listaaRunes->setDataDragon(dd);
|
|
|
|
ui->listClientRunes->setDataDragon(dd);
|
|
|
|
}
|
|
|
|
|
2023-04-23 19:13:49 +02:00
|
|
|
void RuneManager::loadRunes() {
|
2023-05-01 01:23:08 +02:00
|
|
|
if(initialLoadTimer) {
|
|
|
|
initialLoadTimer->deleteLater();
|
|
|
|
initialLoadTimer = nullptr;
|
|
|
|
}
|
|
|
|
|
2023-04-30 16:20:13 +02:00
|
|
|
this->ui->btnRetry->setEnabled(false);
|
|
|
|
QCoreApplication::processEvents();
|
|
|
|
|
2023-04-23 19:13:49 +02:00
|
|
|
if(!client) {
|
|
|
|
auto ca = ClientAccess::find();
|
|
|
|
|
|
|
|
if(ca) {
|
|
|
|
client = std::make_shared<ClientAPI>(*ca.get());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(client) {
|
2023-05-01 22:36:11 +02:00
|
|
|
try {
|
|
|
|
// load meta data
|
|
|
|
runeInfo = client->getAllRuneAspekts();
|
|
|
|
QCoreApplication::processEvents();
|
|
|
|
runeStyles = client->getAllRuneStyles();
|
|
|
|
QCoreApplication::processEvents();
|
2023-04-30 16:20:13 +02:00
|
|
|
|
2023-05-01 22:36:11 +02:00
|
|
|
ui->listClientRunes->setClient(*client);
|
|
|
|
ui->listaaRunes->setClient(*client);
|
2023-04-30 16:20:13 +02:00
|
|
|
|
2023-05-01 22:36:11 +02:00
|
|
|
this->ui->listClientRunes->setRuneInfos(runeInfo, runeStyles);
|
|
|
|
this->ui->listaaRunes->setRuneInfos(runeInfo, runeStyles);
|
2023-04-30 22:10:21 +02:00
|
|
|
|
2023-05-01 22:36:11 +02:00
|
|
|
// load runepages
|
2023-09-02 14:35:53 +02:00
|
|
|
reloadClientRunes();
|
2023-05-01 01:23:08 +02:00
|
|
|
|
2023-05-01 22:36:11 +02:00
|
|
|
// reload runepages - so they ids can get their names
|
|
|
|
reloadAARunes();
|
|
|
|
|
|
|
|
// check if autosync is enabled
|
|
|
|
if(config && config->getConfig().runepagesConfig.autoSync) {
|
|
|
|
syncRunes();
|
|
|
|
}
|
|
|
|
} catch(RestClient::WebException& e) {
|
|
|
|
qCritical() << "webexception: " << e.curlresponse;
|
|
|
|
|
|
|
|
if(e.curlresponse == CURLE_COULDNT_CONNECT) {
|
|
|
|
client.reset();
|
|
|
|
}
|
2023-04-30 22:10:21 +02:00
|
|
|
}
|
2023-04-23 19:13:49 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
setRunesEnabled(!!client); // cast to bool
|
2023-04-30 16:20:13 +02:00
|
|
|
this->ui->btnRetry->setEnabled(true);
|
2023-04-23 19:13:49 +02:00
|
|
|
}
|
|
|
|
|
2023-09-02 14:35:53 +02:00
|
|
|
void RuneManager::reloadClientRunes() {
|
|
|
|
if(client) {
|
|
|
|
const std::vector<ClientAPI::RunePage> runePages = client->getAllRunePages();
|
|
|
|
ui->listClientRunes->loadRunePages(runePages);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-04-23 19:13:49 +02:00
|
|
|
|
|
|
|
void RuneManager::setRunesEnabled(bool enabled) {
|
|
|
|
this->ui->lblClientRunes->setEnabled(enabled);
|
|
|
|
this->ui->listClientRunes->setEnabled(enabled);
|
|
|
|
}
|
|
|
|
|
2023-04-30 16:20:13 +02:00
|
|
|
void RuneManager::saveRunePageClient(int id, QString name, const RunePage& rp) {
|
2023-04-23 19:13:49 +02:00
|
|
|
if(client) {
|
|
|
|
ClientAPI::RunePage newPage;
|
2023-05-31 22:22:23 +02:00
|
|
|
newPage.name = name;
|
2023-04-30 16:20:13 +02:00
|
|
|
newPage.runepage = rp;
|
|
|
|
newPage.id = id;
|
|
|
|
|
2023-05-01 22:36:11 +02:00
|
|
|
try {
|
|
|
|
if(id == -1) {
|
|
|
|
// create new page
|
|
|
|
if(!client->createRunePage(newPage)) {
|
|
|
|
// TODO: some error occured
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// edit existing page
|
|
|
|
if(!client->editRunePage(newPage)) {
|
|
|
|
// TODO: some error occured
|
|
|
|
}
|
2023-04-30 16:20:13 +02:00
|
|
|
}
|
2023-09-02 14:35:53 +02:00
|
|
|
reloadClientRunes();
|
2023-05-01 22:36:11 +02:00
|
|
|
} catch(RestClient::WebException& e) {
|
|
|
|
qCritical() << "webexception: " << e.curlresponse;
|
|
|
|
|
|
|
|
if(e.curlresponse == CURLE_COULDNT_CONNECT) {
|
|
|
|
client.reset();
|
|
|
|
|
|
|
|
setRunesEnabled(false);
|
2023-04-30 16:20:13 +02:00
|
|
|
}
|
2023-04-23 19:13:49 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2023-04-23 23:54:09 +02:00
|
|
|
|
|
|
|
void RuneManager::saveRunePageAA(int id, QString name, const RunePage& rp) {
|
|
|
|
if(!config) return;
|
|
|
|
|
|
|
|
Config::RootConfig& rc = config->getConfig();
|
2023-04-30 22:10:21 +02:00
|
|
|
auto& pages = rc.runepagesConfig.runePages;
|
2023-04-23 23:54:09 +02:00
|
|
|
if(id == -1) {
|
|
|
|
// int newId = pages.size();
|
|
|
|
pages.push_back(std::make_shared<Config::RunePageConfig>(name, rp));
|
|
|
|
} else {
|
|
|
|
if((int) pages.size() > id && id >= 0) {
|
|
|
|
pages.at(id)->runepage = rp;
|
2023-04-30 16:20:13 +02:00
|
|
|
pages.at(id)->name = name;
|
2023-04-23 23:54:09 +02:00
|
|
|
} else {
|
|
|
|
// unkown id
|
|
|
|
qWarning() << "unknown runepage id:" << id;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
config->save();
|
|
|
|
|
|
|
|
// reload runes
|
|
|
|
ui->listaaRunes->loadRunePages(pages);
|
|
|
|
}
|
2023-04-30 16:20:13 +02:00
|
|
|
|
|
|
|
void RuneManager::deleteRunepageClient(int id) {
|
|
|
|
if(client) {
|
2023-05-01 22:36:11 +02:00
|
|
|
try {
|
|
|
|
if(!client->deleteRunePage(id)) {
|
|
|
|
// TODO: some error occured
|
|
|
|
}
|
|
|
|
} catch(RestClient::WebException& e) {
|
|
|
|
qCritical() << "webexception: " << e.curlresponse;
|
|
|
|
|
|
|
|
if(e.curlresponse == CURLE_COULDNT_CONNECT) {
|
|
|
|
client.reset();
|
|
|
|
|
|
|
|
setRunesEnabled(false);
|
|
|
|
}
|
2023-04-30 16:20:13 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void RuneManager::deleteRunepageAA(int id) {
|
|
|
|
if(!config) return;
|
|
|
|
|
|
|
|
Config::RootConfig& rc = config->getConfig();
|
2023-04-30 22:10:21 +02:00
|
|
|
auto& pages = rc.runepagesConfig.runePages;
|
2023-04-30 16:20:13 +02:00
|
|
|
if((int) pages.size() > id && id >= 0) {
|
|
|
|
pages.erase(pages.begin() + id);
|
|
|
|
|
|
|
|
config->save();
|
2023-04-30 16:26:46 +02:00
|
|
|
|
|
|
|
ui->listaaRunes->loadRunePages(pages);
|
2023-04-30 16:20:13 +02:00
|
|
|
} else {
|
|
|
|
// unkown id
|
|
|
|
qWarning() << "unknown runepage id:" << id;
|
|
|
|
}
|
|
|
|
}
|
2023-04-30 22:10:21 +02:00
|
|
|
|
|
|
|
void RuneManager::autoSyncToggled() {
|
|
|
|
bool autoSync = (ui->chkAutoCopy->isChecked());
|
|
|
|
if(config) {
|
|
|
|
config->getConfig().runepagesConfig.autoSync = autoSync;
|
|
|
|
config->save();
|
|
|
|
}
|
|
|
|
|
|
|
|
if(autoSync) {
|
|
|
|
syncRunes();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void RuneManager::syncRunes() {
|
|
|
|
qInfo() << "syncing" << ui->listClientRunes->count() << "runes";
|
|
|
|
|
|
|
|
std::vector<std::shared_ptr<Config::RunePageConfig>>& configs = config->getConfig().runepagesConfig.runePages;
|
|
|
|
bool changed = false;
|
|
|
|
|
|
|
|
for(int i = 0; i < ui->listClientRunes->count(); ++i) {
|
|
|
|
const QListWidgetItem* item = ui->listClientRunes->item(i);
|
|
|
|
QString name = item->text();
|
|
|
|
const RunePage* rp = (RunePage*) item->data(RunePageList::RolePointer).toULongLong();
|
|
|
|
|
|
|
|
auto itFound = std::find_if(configs.cbegin(), configs.cend(), [name, rp](const std::shared_ptr<Config::RunePageConfig>& rpc){
|
|
|
|
return rpc->name == name && *rp == rpc->runepage;
|
|
|
|
});
|
|
|
|
|
|
|
|
if(itFound == configs.cend()) {
|
|
|
|
// no duplicate found -> add it
|
|
|
|
configs.push_back(std::make_shared<Config::RunePageConfig>(name, *rp));
|
|
|
|
changed = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(changed) {
|
|
|
|
config->save();
|
|
|
|
ui->listaaRunes->loadRunePages(configs);
|
|
|
|
}
|
|
|
|
}
|
2023-05-01 01:23:08 +02:00
|
|
|
|
|
|
|
void RuneManager::reloadAARunes() {
|
|
|
|
if(!config) return;
|
|
|
|
|
|
|
|
const auto& pages = config->getConfig().runepagesConfig.runePages;
|
|
|
|
|
|
|
|
// reload runes
|
|
|
|
ui->listaaRunes->loadRunePages(pages);
|
|
|
|
}
|