dbinfo.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 "misc/db/dbinfo.h"
 
#include <QStringBuilder>
 
#include "misc/comparefunctions.h"
 
using namespace swift::misc::network;
 
SWIFT_DEFINE_VALUEOBJECT_MIXINS(swift::misc::db, CDbInfo)
 
namespace swift::misc::db
{
    CDbInfo::CDbInfo(int key, const QString &tableName, int entries)
        : IDatastoreObjectWithIntegerKey(key), m_tableName(tableName.trimmed().toLower()), m_entries(entries)
    {
        this->setEntity(this->getEntity());
        Q_ASSERT_X(tableName.isEmpty() || m_entity != CEntityFlags::NoEntity, Q_FUNC_INFO, "Wrong entity");
    }
 
    bool CDbInfo::isValid() const { return m_entity != CEntityFlags::NoEntity && !m_tableName.isEmpty(); }
 
    CEntityFlags::Entity CDbInfo::getEntity() const
    {
        if (m_entity != CEntityFlags::NoEntity) { return m_entity; }
        const QString tn(this->getTableName());
        return CEntityFlags::singleEntityByName(tn);
    }
 
    const QString &CDbInfo::getSharedFileName() const
    {
        const CEntityFlags::Entity entity = CEntityFlags::singleEntityByName(this->getTableName());
        return CDbInfo::entityToSharedName(entity);
    }
 
    const QString &CDbInfo::getServiceName() const
    {
        const CEntityFlags::Entity entity = CEntityFlags::singleEntityByName(this->getTableName());
        return CDbInfo::entityToServiceName(entity);
    }
 
    void CDbInfo::setEntity(CEntityFlags::Entity entity) { m_entity = entity; }
 
    bool CDbInfo::matchesEntity(CEntityFlags::Entity entity) const
    {
        return entity.testFlag(CEntityFlags::entityToEntityFlag(this->getEntity()));
    }
 
    void CDbInfo::setTableName(const QString &tableName)
    {
        m_tableName = tableName.trimmed().toLower();
        m_entity = this->getEntity();
    }
 
    QString CDbInfo::convertToQString(bool i18n) const
    {
        Q_UNUSED(i18n);
        return QStringLiteral("Table %1 with entries %1").arg(m_tableName).arg(m_entries);
    }
 
    QVariant CDbInfo::propertyByIndex(swift::misc::CPropertyIndexRef index) const
    {
        if (index.isMyself()) { return QVariant::fromValue(*this); }
        const ColumnIndex i = index.frontCasted<ColumnIndex>();
        switch (i)
        {
        case IndexTableName: return QVariant::fromValue(m_tableName);
        case IndexEntries: return QVariant::fromValue(m_entries);
        case IndexEntity: return QVariant::fromValue(m_entity);
        default:
            return (IDatastoreObjectWithIntegerKey::canHandleIndex(index)) ?
                       IDatastoreObjectWithIntegerKey::propertyByIndex(index) :
                       CValueObject::propertyByIndex(index);
        }
    }
 
    void CDbInfo::setPropertyByIndex(CPropertyIndexRef index, const QVariant &variant)
    {
        if (index.isMyself())
        {
            (*this) = variant.value<CDbInfo>();
            return;
        }
        const ColumnIndex i = index.frontCasted<ColumnIndex>();
        switch (i)
        {
        case IndexTableName: this->setTableName(variant.toString()); break;
        case IndexEntries: this->setTableName(variant.toString()); break;
        case IndexEntity: this->setEntity(static_cast<CEntityFlags::Entity>(variant.toInt())); break;
        default:
            if (IDatastoreObjectWithIntegerKey::canHandleIndex(index))
            {
                IDatastoreObjectWithIntegerKey::setPropertyByIndex(index, variant);
            }
            else { CValueObject::setPropertyByIndex(index, variant); }
            break;
        }
    }
 
    int CDbInfo::comparePropertyByIndex(CPropertyIndexRef index, const CDbInfo &compareValue) const
    {
        if (index.isMyself()) { return getTableName().compare(compareValue.getTableName(), Qt::CaseInsensitive); }
        if (IDatastoreObjectWithIntegerKey::canHandleIndex(index))
        {
            return IDatastoreObjectWithIntegerKey::comparePropertyByIndex(index, compareValue);
        }
        const ColumnIndex i = index.frontCasted<ColumnIndex>();
        switch (i)
        {
        case IndexTableName: return this->getTableName().compare(compareValue.getTableName(), Qt::CaseInsensitive);
        case IndexEntries: return Compare::compare(this->getEntries(), compareValue.getEntries());
        case IndexEntity: return Compare::compare(this->getEntity(), compareValue.getEntity());
        default: Q_ASSERT_X(false, Q_FUNC_INFO, "No comparison possible");
        }
        return 0;
    }
 
    CDbInfo CDbInfo::fromDatabaseJson(const QJsonObject &json, const QString &prefix)
    {
        if (!existsKey(json, prefix))
        {
            // when using relationship, this can be null
            return CDbInfo();
        }
        const int id(json.value(prefix % u"id").toInt());
        const int entries(json.value(prefix % u"entries").toInt());
        const QString tableName(json.value(prefix % u"tablename").toString());
        CDbInfo dbInfo(id, tableName, entries);
        dbInfo.setKeyVersionTimestampFromDatabaseJson(json, prefix);
        return dbInfo;
    }
 
    const QStringList &CDbInfo::sharedFileNames()
    {
        static const QStringList names({ "aircrafticao.json", "airlineicao.json", "airports.json", "countries.json",
                                         "distributors.json", "liveries.json", "models.json",
                                         "aircraftcategories.json" });
        return names;
    }
 
    const QString &CDbInfo::sharedInfoFileName()
    {
        static const QString f("dbinfo.json");
        return f;
    }
 
    const QStringList &CDbInfo::serviceNames()
    {
        static const QStringList names({ "jsonaircrafticao.php", "jsonairlineicao.php", "jsonairport.php",
                                         "jsoncountry.php", "jsondistributor.php", "jsonlivery.php",
                                         "jsonaircraftmodel.php", "jsonaircraftcategory.php" });
        return names;
    }
 
    const QString &CDbInfo::entityToSharedName(CEntityFlags::Entity entity)
    {
        static const QString empty;
        switch (entity)
        {
        case CEntityFlags::AircraftIcaoEntity: return sharedFileNames().at(0);
        case CEntityFlags::AirlineIcaoEntity: return sharedFileNames().at(1);
        case CEntityFlags::AirportEntity: return sharedFileNames().at(2);
        case CEntityFlags::CountryEntity: return sharedFileNames().at(3);
        case CEntityFlags::DistributorEntity: return sharedFileNames().at(4);
        case CEntityFlags::LiveryEntity: return sharedFileNames().at(5);
        case CEntityFlags::ModelEntity: return sharedFileNames().at(6);
        case CEntityFlags::AircraftCategoryEntity: return sharedFileNames().at(7);
        default: break;
        }
        return empty;
    }
 
    const QString &CDbInfo::entityToServiceName(CEntityFlags::Entity entity)
    {
        static const QString empty;
        switch (entity)
        {
        case CEntityFlags::AircraftIcaoEntity: return serviceNames().at(0);
        case CEntityFlags::AirlineIcaoEntity: return serviceNames().at(1);
        case CEntityFlags::AirportEntity: return serviceNames().at(2);
        case CEntityFlags::CountryEntity: return serviceNames().at(3);
        case CEntityFlags::DistributorEntity: return serviceNames().at(4);
        case CEntityFlags::LiveryEntity: return serviceNames().at(5);
        case CEntityFlags::ModelEntity: return serviceNames().at(6);
        case CEntityFlags::AircraftCategoryEntity: return serviceNames().at(7);
        default: break;
        }
        return empty;
    }
} // namespace swift::misc::db