server.cpp

// SPDX-FileCopyrightText: Copyright (C) 2013 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
#include "misc/network/server.h"
 
#include <Qt>
#include <QtGlobal>
 
#include "misc/comparefunctions.h"
#include "misc/logcategories.h"
#include "misc/obfuscation.h"
#include "misc/propertyindexref.h"
#include "misc/statusmessage.h"
#include "misc/stringutils.h"
#include "misc/verify.h"
 
SWIFT_DEFINE_VALUEOBJECT_MIXINS(swift::misc::network, CServer)
 
namespace swift::misc::network
{
    CServer::CServer(const QString &name, const QString &description, const QString &address, int port,
                     const CUser &user, const CFsdSetup &fsdSetup, const CEcosystem &ecosytem,
                     bool isAcceptingConnections)
        : m_name(CObfuscation::decode(name)), m_description(CObfuscation::decode(description)),
          m_address(CObfuscation::decode(address)), m_port(port), m_user(user), m_ecosystem(ecosytem),
          m_isAcceptingConnections(isAcceptingConnections), m_fsdSetup(fsdSetup)
    {}
 
    CServer::CServer(const QString &address, int port, const CUser &user)
        : m_name("no name"), m_description("min.configuration"), m_address(address), m_port(port), m_user(user)
    {}
 
    CServer::CServer(const CEcosystem &ecosystem) { this->setEcosystem(ecosystem); }
 
    QString CServer::convertToQString(bool i18n) const
    {
        return QStringLiteral("%1 %2 %3:%4 %5 %6 accepting: %7 FSD: %8 con.since: %9")
            .arg(m_name, m_description, m_address)
            .arg(m_port)
            .arg(m_user.toQString(i18n), m_ecosystem.getSystemString(), boolToYesNo(m_isAcceptingConnections),
                 m_fsdSetup.toQString(i18n), this->isConnected() ? this->getFormattedUtcTimestampHms() : "not con.");
    }
 
    const CServer &CServer::fscFsdServer()
    {
        static const CServer fsc = [] {
            CServer s = CServer("FSC", "FSC e.V.", "OBF:AwJIKfgkQDJEIRnno29DJlB+UK0=", 6809, CUser(), CFsdSetup(),
                                CEcosystem(CEcosystem::privateFsd()));
            s.removeSendReceiveDetails(CFsdSetup::AllInterimPositions);
            return s;
        }();
        return fsc;
    }
 
    const CServer &CServer::esTowerView()
    {
        static const CServer s = CServer("ES Tower", "Euroscope Tower view", "localhost", 6809, CUser(),
                                         CFsdSetup::vatsimStandard(), CEcosystem(CEcosystem::vatsim()));
        return s;
    }
 
    bool CServer::matchesName(const QString &name) const
    {
        return m_name.length() == name.length() && m_name.startsWith(name, Qt::CaseInsensitive);
    }
 
    bool CServer::matchesAddressPort(const CServer &server) const
    {
        return server.getPort() == this->getPort() && server.matchesAddress(this->getAddress());
    }
 
    bool CServer::matchesAddress(const QString &address) const
    {
        return m_address.length() == address.length() && m_address.startsWith(address, Qt::CaseInsensitive);
    }
 
    void CServer::setEcosystem(const CEcosystem &ecosystem) { m_ecosystem = ecosystem; }
 
    bool CServer::isValidForLogin() const
    {
        return m_user.hasCredentials() && this->hasAddressAndPort() && this->isAcceptingConnections();
    }
 
    bool CServer::hasAddressAndPort() const { return m_port > 0 && !m_address.isEmpty(); }
 
    bool CServer::isConnected() const { return m_timestampMSecsSinceEpoch >= 0; }
 
    bool CServer::isNull() const { return m_ecosystem.isUnspecified() && !this->hasName() && m_port < 0; }
 
    CStatusMessageList CServer::validate() const
    {
        static const CLogCategoryList cats(CLogCategoryList(this).withValidation());
        CStatusMessageList msgs;
        if (this->getName().isEmpty())
        {
            msgs.push_back(CStatusMessage(CStatusMessage::SeverityError, u"Missing name"));
        }
        if (this->getAddress().isEmpty())
        {
            msgs.push_back(CStatusMessage(CStatusMessage::SeverityError, u"Missing address"));
        }
        if (this->getDescription().isEmpty())
        {
            msgs.push_back(CStatusMessage(CStatusMessage::SeverityWarning, u"Missing description"));
        }
        if (this->getPort() < 1 || this->getPort() > 65535)
        {
            msgs.push_back(CStatusMessage(CStatusMessage::SeverityError, u"Wrong port"));
        }
        msgs.push_back(this->getUser().validate());
        msgs.push_back(this->getFsdSetup().validate());
        msgs.addCategories(cats);
        msgs.sortBySeverity();
        return msgs;
    }
 
    QString CServer::getServerSessionId(bool onlyConnected) const
    {
        const bool isConnected = this->isConnected();
        if (onlyConnected && !isConnected) { return {}; }
        static const QString session("%1 %2 %3:%4 [%5] %6 %7");
        return session.arg(isConnected ? u"connected" : u"disconnected")
            .arg(this->getName(), this->getAddress())
            .arg(this->getPort())
            .arg(this->getEcosystem().getSystemString(), this->getUser().getRealName(),
                 this->getFormattedUtcTimestampHms());
    }
 
    QVariant CServer::propertyByIndex(CPropertyIndexRef index) const
    {
        if (index.isMyself()) { return QVariant::fromValue(*this); }
        if (ITimestampBased::canHandleIndex(index)) { return ITimestampBased::propertyByIndex(index); }
 
        const auto i = index.frontCasted<ColumnIndex>();
        switch (i)
        {
        case IndexAddress: return QVariant::fromValue(m_address);
        case IndexDescription: return QVariant::fromValue(m_description);
        case IndexName: return QVariant::fromValue(m_name);
        case IndexPort: return QVariant::fromValue(m_port);
        case IndexUser: return m_user.propertyByIndex(index.copyFrontRemoved());
        case IndexFsdSetup: return m_fsdSetup.propertyByIndex(index.copyFrontRemoved());
        case IndexEcosystem: return m_ecosystem.propertyByIndex(index.copyFrontRemoved());
        case IndexIsAcceptingConnections: return QVariant::fromValue(m_isAcceptingConnections);
        default: return CValueObject::propertyByIndex(index);
        }
    }
 
    void CServer::setPropertyByIndex(CPropertyIndexRef index, const QVariant &variant)
    {
        if (index.isMyself())
        {
            (*this) = variant.value<CServer>();
            return;
        }
        if (ITimestampBased::canHandleIndex(index))
        {
            ITimestampBased::setPropertyByIndex(index, variant);
            return;
        }
 
        const auto i = index.frontCasted<ColumnIndex>();
        switch (i)
        {
        case IndexAddress: this->setAddress(variant.value<QString>()); break;
        case IndexPort: this->setPort(variant.value<qint32>()); break;
        case IndexDescription: this->setDescription(variant.value<QString>()); break;
        case IndexName: this->setName(variant.value<QString>()); break;
        case IndexUser: m_user.setPropertyByIndex(index.copyFrontRemoved(), variant); break;
        case IndexFsdSetup: m_fsdSetup.setPropertyByIndex(index.copyFrontRemoved(), variant); break;
        case IndexEcosystem: m_ecosystem.setPropertyByIndex(index.copyFrontRemoved(), variant); break;
        case IndexIsAcceptingConnections: this->setIsAcceptingConnections(variant.value<bool>()); break;
        default: CValueObject::setPropertyByIndex(index, variant); break;
        }
    }
 
    int CServer::comparePropertyByIndex(CPropertyIndexRef index, const CServer &compareValue) const
    {
        if (index.isMyself()) { return this->getName().compare(compareValue.getName()); }
        if (ITimestampBased::canHandleIndex(index))
        {
            return ITimestampBased::comparePropertyByIndex(index, compareValue);
        }
        const auto i = index.frontCasted<ColumnIndex>();
        switch (i)
        {
        case IndexAddress: return this->getAddress().compare(compareValue.getAddress(), Qt::CaseInsensitive);
        case IndexDescription:
            return this->getDescription().compare(compareValue.getDescription(), Qt::CaseInsensitive);
        case IndexFsdSetup:
            return m_fsdSetup.comparePropertyByIndex(index.copyFrontRemoved(), compareValue.getFsdSetup());
        case IndexName: return this->getName().compare(compareValue.getName(), Qt::CaseInsensitive);
        case IndexPort: return Compare::compare(this->getPort(), compareValue.getPort());
        case IndexUser: return this->getUser().comparePropertyByIndex(index.copyFrontRemoved(), compareValue.getUser());
        case IndexEcosystem:
            return this->getEcosystem().comparePropertyByIndex(index.copyFrontRemoved(), compareValue.getEcosystem());
        case IndexIsAcceptingConnections:
            return Compare::compare(this->isAcceptingConnections(), compareValue.isAcceptingConnections());
        default: break;
        }
        SWIFT_VERIFY_X(false, Q_FUNC_INFO, qUtf8Printable("No comparison for index " + index.toQString()));
        return 0;
    }
 
    void CServer::setAddress(const QString &address) { m_address = CObfuscation::decode(address); }
 
    void CServer::setName(const QString &name) { m_name = CObfuscation::decode(name); }
 
    void CServer::setDescription(const QString &description)
    {
        m_description = CObfuscation::decode(description).simplified();
    }
} // namespace swift::misc::network