dbquickmappingwizard.cpp

// SPDX-FileCopyrightText: Copyright (C) 2016 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
#include "dbquickmappingwizard.h"
 
#include <QStringBuilder>
 
#include "ui_dbquickmappingwizard.h"
 
#include "config/buildconfig.h"
#include "core/context/contextsimulator.h"
#include "core/db/databasewriter.h"
#include "core/webdataservices.h"
#include "gui/components/dbaircrafticaoselectorcomponent.h"
#include "gui/components/dbairlinenameselectorcomponent.h"
#include "gui/guiapplication.h"
#include "gui/guiutility.h"
#include "gui/uppercasevalidator.h"
#include "gui/views/aircrafticaoview.h"
#include "gui/views/distributorview.h"
#include "gui/views/liveryview.h"
 
using namespace swift::core;
using namespace swift::core::db;
using namespace swift::config;
using namespace swift::misc;
using namespace swift::misc::aviation;
using namespace swift::misc::simulation;
 
namespace swift::gui::components
{
    CDbQuickMappingWizard::CDbQuickMappingWizard(QWidget *parent) : QWizard(parent), ui(new Ui::CDbQuickMappingWizard)
    {
        Q_ASSERT_X(sGui, Q_FUNC_INFO, "Missing sGui");
        Q_ASSERT_X(sGui->hasWebDataServices(), Q_FUNC_INFO, "Missing web services");
        Q_ASSERT_X(sGui->getWebDataServices()->getDatabaseWriter(), Q_FUNC_INFO, "Missing writer");
 
        ui->setupUi(this);
        ui->selector_AircraftIcaoCode->setFocus();
        ui->selector_AircraftIcaoCode->displayWithIcaoDescription(false);
        ui->selector_AircraftIcaoCode->displayMode(CDbAircraftIcaoSelectorComponent::DisplayCompleterString);
        ui->selector_AirlineIcaoCode->displayWithIcaoDescription(false);
        ui->selector_Simulator->setNoSelectionMeansAll(false);
        ui->selector_Simulator->setRememberSelection(false);
        ui->editor_AircraftModel->allowDrop(false);
        ui->editor_AircraftModel->setReadOnly(true);
        CGuiUtility::checkBoxReadOnly(ui->cb_Military, true);
        CGuiUtility::checkBoxReadOnly(ui->cb_VirtualAirline, true);
 
        connect(sGui->getWebDataServices(), &CWebDataServices::swiftDbAllDataRead, this,
                &CDbQuickMappingWizard::onWebDataRead, Qt::QueuedConnection);
        connect(sGui->getWebDataServices()->getDatabaseWriter(), &CDatabaseWriter::publishedModels, this,
                &CDbQuickMappingWizard::onPublishedModels, Qt::QueuedConnection);
 
        connect(this, &CDbQuickMappingWizard::currentIdChanged, this, &CDbQuickMappingWizard::currentWizardPageChanged);
        connect(ui->selector_AircraftIcaoCode, &CDbAircraftIcaoSelectorComponent::changedAircraftIcao, this,
                &CDbQuickMappingWizard::onAircraftSelected, Qt::QueuedConnection);
        connect(ui->selector_AirlineIcaoCode, &CDbAirlineIcaoSelectorComponent::changedAirlineIcao, this,
                &CDbQuickMappingWizard::onAirlineSelected, Qt::QueuedConnection);
        connect(ui->selector_AirlineName, &CDbAirlineIcaoSelectorComponent::changedAirlineIcao, this,
                &CDbQuickMappingWizard::onAirlineSelected, Qt::QueuedConnection);
 
        ui->comp_Log->showFilterDialog(); // filter for log normally not needed, so dialog (not bar)
        CGuiUtility::setWizardButtonWidths(this);
 
        // init if data already available
        this->onWebDataRead();
    }
 
    CDbQuickMappingWizard::~CDbQuickMappingWizard() {}
 
    const QStringList &CDbQuickMappingWizard::getLogCategories()
    {
        static const QStringList cats { CLogCategories::mapping(), CLogCategories::guiComponent() };
        return cats;
    }
 
    void CDbQuickMappingWizard::keyPressEvent(QKeyEvent *event)
    {
        Qt::Key key = static_cast<Qt::Key>(event->key());
        if (key == Qt::Key_Enter || key == Qt::Key_Return)
        {
            // disable enter, interferes with filter returnPressed
            event->accept();
        }
        else { QWizard::keyPressEvent(event); }
    }
 
    void CDbQuickMappingWizard::presetAircraftIcao(const CAircraftIcaoCode &aircraftIcao)
    {
        this->clear();
        ui->selector_AircraftIcaoCode->setAircraftIcao(aircraftIcao);
        ui->selector_AircraftIcaoCode->setFocus();
    }
 
    void CDbQuickMappingWizard::presetModel(const CAircraftModel &model)
    {
        QString ms = model.getModelString();
        if (!model.getDescription().isEmpty()) { ms += u" (" % model.getDescription() % u")"; }
 
        this->presetAircraftIcao(model.getAircraftIcaoCode());
        ui->selector_AirlineIcaoCode->setAirlineIcao(model.getAirlineIcaoCode());
        ui->selector_AirlineName->setAirlineIcao(model.getAirlineIcaoCode());
        ui->comp_Distributor->view()->selectDbKey(model.getDistributor().getDbKey());
        ui->le_ModelString->setText(model.hasModelString() ? ms : "<no model string>");
        ui->selector_AircraftIcaoCode->setFocus();
 
        const CLivery livery(model.getLivery());
        if (livery.isColorLivery())
        {
            ui->comp_ColorSearch->presetColorLivery(livery);
            ui->rb_ColorLivery->setChecked(true);
        }
 
        m_model = model;
    }
 
    void CDbQuickMappingWizard::clear()
    {
        m_lastId = 0;
        ui->editor_AircraftModel->clear();
        ui->comp_Log->clear();
        this->restart();
    }
 
    void CDbQuickMappingWizard::setAircraftIcaoFilter()
    {
        const CAircraftIcaoCode icao(ui->selector_AircraftIcaoCode->getAircraftIcao());
        if (icao.isLoadedFromDb())
        {
            ui->comp_AircraftIcao->view()->sortByPropertyIndex(CAircraftIcaoCode::IndexRank);
            ui->comp_AircraftIcao->filter(icao);
            ui->comp_AircraftIcao->selectAircraftIcao(icao);
        }
    }
 
    void CDbQuickMappingWizard::setAirlineIcaoFilter()
    {
        const CAirlineIcaoCode icao(ui->selector_AirlineIcaoCode->getAirlineIcao());
        if (icao.isLoadedFromDb())
        {
            ui->comp_Livery->view()->sortByPropertyIndex(CLivery::IndexDbIntegerKey);
            ui->comp_Livery->filterByAirline(icao);
            ui->comp_Livery->view()->selectRow(0);
        }
    }
 
    void CDbQuickMappingWizard::setColorFilter()
    {
        const CLivery colorLivery(ui->comp_ColorSearch->getLivery());
        if (colorLivery.isLoadedFromDb())
        {
            ui->comp_Livery->filter(colorLivery);
            ui->comp_Livery->view()->selectRow(0);
        }
    }
 
    void CDbQuickMappingWizard::setDistributorFilter()
    {
        const CSimulatorInfo sims = this->guessSimulator();
        ui->comp_Distributor->filterBySimulator(sims);
        if (m_model.getDistributor().isLoadedFromDb())
        {
            const bool s = ui->comp_Distributor->selectDistributor(m_model.getDistributor());
            Q_UNUSED(s);
        }
    }
 
    CLivery CDbQuickMappingWizard::getFirstSelectedOrDefaultLivery() const
    {
        const CLivery l = ui->comp_Livery->view()->firstSelectedOrDefaultObject();
        if (l.isLoadedFromDb()) { return l; }
        if (m_model.getLivery().isLoadedFromDb()) { return m_model.getLivery(); }
        return l;
    }
 
    CAircraftIcaoCode CDbQuickMappingWizard::getFirstSelectedOrDefaultAircraftIcao() const
    {
        const CAircraftIcaoCode icao = ui->comp_AircraftIcao->view()->firstSelectedOrDefaultObject();
        if (icao.isLoadedFromDb()) { return icao; }
        if (m_model.getAircraftIcaoCode().isLoadedFromDb()) { return m_model.getAircraftIcaoCode(); }
        return icao;
    }
 
    swift::misc::simulation::CDistributor CDbQuickMappingWizard::getFirstSelectedOrDefaultDistributor() const
    {
        const CDistributor dist = ui->comp_Distributor->view()->firstSelectedOrDefaultObject();
        if (dist.isLoadedFromDb()) { return dist; }
        if (m_model.getDistributor().isLoadedFromDb()) { return m_model.getDistributor(); }
        return dist;
    }
 
    void CDbQuickMappingWizard::onWebDataRead()
    {
        if (!sGui || !sGui->hasWebDataServices()) { return; }
    }
 
    void CDbQuickMappingWizard::onPublishedModels(const CAircraftModelList &modelsPublished,
                                                  const CAircraftModelList &modelsSkipped,
                                                  const CStatusMessageList &messages, bool requestSuccessful,
                                                  bool directWrite)
    {
        Q_UNUSED(modelsPublished);
        Q_UNUSED(modelsSkipped);
        Q_UNUSED(directWrite);
        CStatusMessageList msgs;
        if (requestSuccessful)
        {
            msgs.push_back(CStatusMessage(this, CStatusMessage::SeverityInfo, u"Publishing request sent"));
        }
        else { msgs.push_back(CStatusMessage(this, CStatusMessage::SeverityError, u"Publishing request failed")); }
        msgs.push_back(messages);
        ui->comp_Log->appendStatusMessagesToList(msgs);
    }
 
    void CDbQuickMappingWizard::currentWizardPageChanged(int id)
    {
        const bool forward = id > m_lastId;
        const bool colorMode = ui->rb_ColorLivery->isChecked();
        m_lastId = id;
 
        const Pages page = static_cast<Pages>(id);
        switch (page)
        {
        case PageAircraftSelect:
        {
            this->setAircraftIcaoFilter();
        }
        break;
        case PageColor:
            if (!colorMode) { forward ? this->next() : this->back(); }
            break;
        case PageLiverySelect:
        {
            if (colorMode) { this->setColorFilter(); }
            else { this->setAirlineIcaoFilter(); }
        }
        break;
        case PageDistributorSelect:
        {
            this->setDistributorFilter();
        }
        break;
        case PageConfirmation:
        {
            const CSimulatorInfo sims = this->guessSimulator();
            ui->selector_Simulator->setValue(sims);
            ui->editor_AircraftModel->setLivery(this->getFirstSelectedOrDefaultLivery());
            ui->editor_AircraftModel->setDistributor(this->getFirstSelectedOrDefaultDistributor());
            ui->editor_AircraftModel->setAircraftIcao(this->getFirstSelectedOrDefaultAircraftIcao());
            const CStatusMessageList msgs(this->validateData());
            const bool errorFree = !msgs.hasWarningOrErrorMessages();
            ui->fr_ConfirmationOk->setVisible(errorFree);
            ui->fr_ConfirmationStillErrors->setVisible(!errorFree);
            if (!errorFree) { ui->wp6_Confirmation->showOverlayMessages(msgs); }
        }
        break;
        case PageCredentials:
        {
            ui->comp_Log->clear();
        }
        break;
        case PageLastConfirmation:
        {
            // void
        }
        break;
        case PageSendStatus:
        {
            this->writeModelToDb();
            this->button(BackButton)->hide();
        }
        break;
        default: break;
        }
    }
 
    bool CDbQuickMappingWizard::validateCurrentPage()
    {
        const Pages page = static_cast<Pages>(this->currentId());
        bool ok = false;
        switch (page)
        {
        case PageConfirmation:
        {
            const CStatusMessageList msgs(this->validateData());
            if (!msgs.isEmpty()) { ui->wp6_Confirmation->showOverlayMessages(msgs); }
            ok = !msgs.hasWarningOrErrorMessages();
        }
        break;
        case PageCredentials:
        {
            ok = ui->comp_DbLogin->isUserAuthenticated();
            if (!ok)
            {
                ui->wp7_Credentials->showOverlayHTMLMessage("No user credentials, read login hints!", 10 * 1000);
            }
        }
        break;
        default:
        {
            ok = true;
        }
        break;
        }
 
        return ok;
    }
 
    CStatusMessageList CDbQuickMappingWizard::validateData() const
    {
        CStatusMessageList msgs(ui->editor_AircraftModel->validate(true));
        if (ui->le_ModelString->text().isEmpty())
        {
            const CStatusMessage error(this, CStatusMessage::SeverityError, u"Missing model string", true);
            msgs.push_back(error);
        }
 
        const CStatusMessage vMsg = ui->selector_Simulator->getValue().validateSimulatorsForModel();
        if (vMsg.isWarningOrAbove()) { msgs.push_back(vMsg); }
 
        return msgs;
    }
 
    void CDbQuickMappingWizard::consolidateModelWithUIData()
    {
        CAircraftModel model = m_model;
        model.setAircraftIcaoCode(ui->editor_AircraftModel->getAircraftIcao());
        model.setDistributor(ui->editor_AircraftModel->getDistributor());
        model.setLivery(ui->editor_AircraftModel->getLivery());
        model.setSimulator(ui->selector_Simulator->getValue());
        m_model = model;
    }
 
    CSimulatorInfo CDbQuickMappingWizard::guessSimulator() const
    {
        CSimulatorInfo sims = m_model.getSimulator();
        if (!sims.isAnySimulator() && m_model.hasModelString() && sGui && sGui->hasWebDataServices())
        {
            const CAircraftModel m = sGui->getWebDataServices()->getModelForModelString(m_model.getModelString());
            if (m.isLoadedFromDb()) { sims = m.getSimulator(); }
        }
 
        if (sGui && !sGui->isShuttingDown() && sGui->getIContextSimulator() &&
            sGui->getIContextSimulator()->isSimulatorAvailable())
        {
            sims.add(sGui->getIContextSimulator()->getSimulatorPluginInfo().getSimulator());
        }
        return sims;
    }
 
    void CDbQuickMappingWizard::writeModelToDb()
    {
        if (!sGui || sGui->isShuttingDown() || !sGui->getWebDataServices() ||
            !sGui->getWebDataServices()->getDatabaseWriter())
        {
            return;
        }
        this->consolidateModelWithUIData();
 
        // make sure the model is correctly excluded for XP etc.
        static const QString qmw(u"[swift QMW " % CBuildConfig::getVersionString() % u"]");
        if (m_model.getSimulator().isXPlane()) { m_model.setModelMode(CAircraftModel::Exclude); }
        m_model.setVersion(CBuildConfig::getVersionString());
        const QString extraInfo = QString(m_model.getDescription() % u" " % qmw).simplified().trimmed();
 
        const CStatusMessageList msgs =
            sGui->getWebDataServices()->getDatabaseWriter()->asyncPublishModel(m_model, extraInfo);
        ui->comp_Log->appendStatusMessagesToList(msgs);
    }
 
    void CDbQuickMappingWizard::onAirlineSelected(const CAirlineIcaoCode &icao)
    {
        if (icao.isLoadedFromDb())
        {
            ui->cb_VirtualAirline->setChecked(icao.isVirtualAirline());
            ui->cb_Military->setChecked(icao.isMilitary());
            ui->selector_AirlineName->setAirlineIcao(icao);
            ui->selector_AirlineIcaoCode->setAirlineIcao(icao);
            // already trigger sorting, if sorting is already correct it does nothing
            // avoids issue with later selection overridden by sorting/filtering
            this->setAirlineIcaoFilter();
        }
    }
 
    void CDbQuickMappingWizard::onAircraftSelected(const CAircraftIcaoCode &icao)
    {
        if (icao.isLoadedFromDb())
        {
            ui->cb_Military->setChecked(icao.isMilitary());
            // already trigger sorting, if sorting is already correct it does nothing
            // avoids issue with later selection overidden by sorting/filtering
            this->setAircraftIcaoFilter();
        }
    }
} // namespace swift::gui::components