server.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2013 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_MISC_NETWORK_SERVER_H
#define SWIFT_MISC_NETWORK_SERVER_H
 
#include <QMetaType>
#include <QString>
 
#include "misc/metaclass.h"
#include "misc/network/ecosystem.h"
#include "misc/network/fsdsetup.h"
#include "misc/network/user.h"
#include "misc/propertyindexref.h"
#include "misc/statusmessagelist.h"
#include "misc/swiftmiscexport.h"
#include "misc/timestampbased.h"
#include "misc/valueobject.h"
 
SWIFT_DECLARE_VALUEOBJECT_MIXINS(swift::misc::network, CServer)
 
namespace swift::misc::network
{
    class SWIFT_MISC_EXPORT CServer : public CValueObject<CServer>, public ITimestampBased
    {
    public:
        enum ColumnIndex
        {
            IndexName = CPropertyIndexRef::GlobalIndexCServer,
            IndexDescription,
            IndexAddress,
            IndexPort,
            IndexUser,
            IndexFsdSetup,
            IndexEcosystem,
            IndexIsAcceptingConnections,
            IndexServerType,
            IndexServerTypeAsString
        };
 
        enum ServerType
        {
            Unspecified,
            FSDServerVatsim,
            FSDServer,
            VoiceServerVatsim,
            VoiceServer,
            WebService,
        };
 
        static const QList<int> &allServerTypes();
 
        static const QString &serverTypeToString(ServerType server);
 
        CServer() {}
 
        CServer(const QString &name, const QString &description, const QString &address, int port, const CUser &user,
                const CFsdSetup &fsdSetup, const CEcosystem &ecosytem, ServerType serverType,
                bool isAcceptingConnections = true);
 
        CServer(const QString &address, int port, const CUser &user);
 
        CServer(const CEcosystem &ecosystem);
 
        CServer(ServerType serverType);
 
        const QString &getAddress() const { return m_address; }
 
        void setAddress(const QString &address);
 
        const CUser &getUser() const { return m_user; }
 
        void setUser(const CUser &user) { m_user = user; }
 
        const QString &getName() const { return m_name; }
 
        bool hasName() const { return !m_name.isEmpty(); }
 
        void setName(const QString &name);
 
        bool matchesName(const QString &name) const;
 
        bool matchesAddressPort(const CServer &server) const;
 
        bool matchesAddress(const QString &address) const;
 
        const QString &getDescription() const { return m_description; }
 
        void setDescription(const QString &description);
 
        int getPort() const { return m_port; }
 
        void setPort(int port) { m_port = port; }
 
        const CEcosystem &getEcosystem() const { return m_ecosystem; }
 
        bool setEcosystem(const CEcosystem &ecosystem);
 
        bool isAcceptingConnections() const { return m_isAcceptingConnections; }
 
        void setIsAcceptingConnections(bool value) { m_isAcceptingConnections = value; }
 
        bool isValidForLogin() const;
 
        bool hasAddressAndPort() const;
 
        const CFsdSetup &getFsdSetup() const { return m_fsdSetup; }
 
        void setFsdSetup(const CFsdSetup &setup) { m_fsdSetup = setup; }
 
        void addSendReceiveDetails(CFsdSetup::SendReceiveDetails sendReceive)
        {
            m_fsdSetup.addSendReceiveDetails(sendReceive);
        }
 
        void removeSendReceiveDetails(CFsdSetup::SendReceiveDetails sendReceive)
        {
            m_fsdSetup.removeSendReceiveDetails(sendReceive);
        }
 
        bool isFsdServer() const;
 
        bool setServerType(ServerType serverType);
 
        ServerType getServerType() const { return static_cast<ServerType>(m_serverType); }
 
        bool hasUnspecifiedServerType() const;
 
        const QString &getServerTypeAsString() const;
 
        QDateTime getConnectedSince() const { return this->getUtcTimestamp(); }
 
        void setConnectedSinceNow() { this->setCurrentUtcTime(); }
 
        void markAsDisconnected() { this->setTimestampToNull(); }
 
        bool isConnected() const;
 
        bool isNull() const;
 
        CStatusMessageList validate() const;
 
        QString getServerSessionId(bool onlyConnected) const;
 
        QVariant propertyByIndex(CPropertyIndexRef index) const;
 
        void setPropertyByIndex(CPropertyIndexRef index, const QVariant &variant);
 
        int comparePropertyByIndex(CPropertyIndexRef index, const CServer &compareValue) const;
 
        QString convertToQString(bool i18n = false) const;
 
        static const CServer &fscFsdServer();
 
        static const CServer &esTowerView();
 
    private:
        QString m_name;
        QString m_description;
        QString m_address;
        int m_port = -1;
        CUser m_user;
        CEcosystem m_ecosystem;
        int m_serverType = static_cast<int>(Unspecified);
        bool m_isAcceptingConnections = true; 
        CFsdSetup m_fsdSetup;
 
        SWIFT_METACLASS(
            CServer,
            SWIFT_METAMEMBER(name),
            SWIFT_METAMEMBER(description),
            SWIFT_METAMEMBER(address),
            SWIFT_METAMEMBER(port),
            SWIFT_METAMEMBER(user),
            SWIFT_METAMEMBER(fsdSetup),
            SWIFT_METAMEMBER(ecosystem),
            SWIFT_METAMEMBER(serverType),
            SWIFT_METAMEMBER(isAcceptingConnections),
            SWIFT_METAMEMBER(timestampMSecsSinceEpoch, 0, DisabledForJson | DisabledForComparison));
    };
} // namespace swift::misc::network
 
Q_DECLARE_METATYPE(swift::misc::network::CServer)
Q_DECLARE_METATYPE(swift::misc::network::CServer::ServerType)
 
#endif // SWIFT_MISC_NETWORK_SERVER_H