licencemanager.cpp

Go to the documentation of this file.

#include <QSqlDatabase>
#include <QSqlQuery>
 
#include "licencemanager.h"
 
LicenceManager::LicenceManager::LicenceManager(Ui::MainWindow* UI_Window)
{
    ui = UI_Window;
 
 
    QObject::connect(ui->UpdateQtLicence, SIGNAL(pressed()), this, SLOT(SaveQtLicence()));
    QObject::connect(ui->SoftwareLicenceList, SIGNAL(currentIndexChanged(int)), this, SLOT(SetSoftwareLicence(int)));
    QObject::connect(ui->HardwareLicenceList, SIGNAL(currentIndexChanged(int)), this, SLOT(SetHardwareLicence(int)));
    QObject::connect(ui->DocumentationLicenceList, SIGNAL(currentIndexChanged(int)), this, SLOT(SetDocumentationLicence(int)));
}
 
void LicenceManager::LoadLicences()
{
    QSqlDatabase db = QSqlDatabase::database();
 
    // Clear the Licence List
    ui->SoftwareLicenceList->clear();
 
    // Get a List of the Development Families from Database
    QSqlQuery soft_licence_query( "select licence_index, short_name from licence where licence_type = 1 or licence_type = 3 order by short_name" );
 
    // Step through the Results
    int row_index = 0;
    while ( soft_licence_query.next() )
    {
        int licence_index = soft_licence_query.value(0).toInt();
        QString software_entry = soft_licence_query.value(1).toString();
        ui->SoftwareLicenceList->addItem( software_entry, licence_index );
        row_index++;
    }
    SendStatusMessage("Software Licence", row_index);
 
    // Clear the Licence List
    ui->DocumentationLicenceList->clear();
 
    // Get a List of the Development Families from Database
    QSqlQuery doc_licence_query( "select licence_index, short_name from licence where licence_type = 1 or licence_type = 2 order by short_name" );
 
    // Step through the Results
    row_index = 0;
    while ( doc_licence_query.next() )
    {
        int licence_index = doc_licence_query.value(0).toInt();
        QString doc_licence_entry = doc_licence_query.value(1).toString();
        ui->DocumentationLicenceList->addItem( doc_licence_entry, licence_index );
        row_index++;
    }
    SendStatusMessage("Documentation Licence", row_index);
 
    // Clear the Licence List
    ui->HardwareLicenceList->clear();
 
    // Get a List of the Development Families from Database
    QSqlQuery hardware_licence_query( "select licence_index, short_name from licence where licence_type = 1 or licence_type = 4 order by short_name" );
 
    // Step through the Results
    row_index = 0;
    while ( hardware_licence_query.next() )
    {
        int licence_index = hardware_licence_query.value(0).toInt();
        QString hardware_entry = hardware_licence_query.value(1).toString();
        ui->HardwareLicenceList->addItem( hardware_entry, licence_index );
        row_index++;
    }
    SendStatusMessage("Hardware Licence", row_index);
 
    // Initialise the Qt Licence List
    ui->QtLicenceList->clear();
    ui->QtLicenceList->addItems({QString("Community"), QString("Professional"), QString("Enterprise")});
    SendStatusMessage("Qt Licence List", 3);
 
    LoadQtLicence();
}
 
void LicenceManager::SendStatusMessage(QString Type, int Counter)
{
    if (Counter > 0)
    {
        LogAdd(LOG_DEBUG, MODE_DATABASE, QString("%1 Loaded with %2 entries.").arg(Type, QString::number(Counter)));
    }
    else
    {
        LogAdd(LOG_ERROR, MODE_DATABASE, QString("%1 FAILED to load any entries.").arg(Type, Counter));
    }
}
 
void LicenceManager::LoadQtLicence(void)
{
    // Open the Settings Data
    QSettings settings( "brigadoon/netprojectmanager" );
    ui->QtLicenceList->setCurrentText(settings.value( "Qt/Licence", "Community").toString());
    LogAdd(LOG_DEBUG, MODE_CONFIG, QString("Qt Licence for Site loaded as %1.").arg(ui->QtLicenceList->currentText()));
}
 
void LicenceManager::SaveQtLicence(void)
{
    // Open the Settings Data
    QSettings settings( "brigadoon/netprojectmanager" );
    settings.setValue( "Qt/Licence", ui->QtLicenceList->currentText());
    LogAdd(LOG_INFO, MODE_CONFIG, QString("Qt Licence for Site saved as %1.").arg(ui->QtLicenceList->currentText()));
}
 
void LicenceManager::LogAdd(LOGGING_SEVERITY Severity, LOGGING_MODE Mode, const QString Message)
{
    REMOTE_LOG_ENTRY log_entry;
    log_entry.Severity = Severity;
    log_entry.Mode = Mode;
    log_entry.Message = Message;
    emit SendLogEntry(log_entry);
}
 
void LicenceManager::ReadPrimaryTool( int ToolIndex)
{
    // Assume No Restrictions will be found
    ui->SoftwareLicenceList->setEnabled(true);
    ui->DocumentationLicenceList->setEnabled(true);
    ui->HardwareLicenceList->setEnabled(true);
 
    QSqlDatabase db = QSqlDatabase::database();
 
    // See if there is a Licence Restriction for this Tool from Database
    QSqlQuery tool_restriction_query( QString("select software_licence_restriction, documentation_licence_restriction, hardware_licence_restriction from compiler_instance where compiler_instance_index = %1").arg(QString::number(ToolIndex+1)));
 
    // Find Any Licence Restrictions for the Primary Tool
    int row_index = 0;
    int software_restriction; int documentation_restriction; int hardware_restriction;
    while ( tool_restriction_query.next() )
    {
        software_restriction = tool_restriction_query.value(0).toInt();
        documentation_restriction = tool_restriction_query.value(1).toInt();
        hardware_restriction = tool_restriction_query.value(2).toInt();
        row_index++;
    }
 
    // If Entries were found for the Primary Tool, Process Them
    if (row_index != 0)
    {
        // Process Software Licemce Exceptions (if any)
        bool do_software_restriction = true;
 
        // Apply Special Exceptions (if any)
        if ((ToolIndex == 2) &&(ui->QtLicenceList->currentIndex() != 0)) do_software_restriction = false;
 
        // Process the Software Restrictions
        if (do_software_restriction) ProcessSoftwareRestriction(software_restriction);
 
        // Process Software Licemce Exceptions (if any)
        bool do_documentation_restriction = false;
 
        // Apply Special Exceptions (if any)
 
 
        // Process the Documenttaion Restrictions
        if (do_documentation_restriction) ProcessDocumentationRestriction(documentation_restriction);
 
        // Process Software Licemce Exceptions (if any)
        bool do_hardware_restriction = false;
 
        // Apply Special Exceptions (if any)
 
 
        // Process the Software Restrictions
        if (do_hardware_restriction) ProcessHardwareRestriction(hardware_restriction);
    }
}
 
void LicenceManager::ProcessSoftwareRestriction(int SoftwareRestriction)
{
    QString licence_name;
    bool licence_enabled = true;
 
    // Check if there is No Software ERestriction
    if (SoftwareRestriction != 0)
    {
        QSqlDatabase db = QSqlDatabase::database();
        int row_index = 0;
        QSqlQuery licence_restriction_query(QString("select short_name from licence where licence_index = %1").arg(QString::number(SoftwareRestriction)));
        while ( licence_restriction_query.next() )
        {
            licence_name = licence_restriction_query.value(0).toString();
            row_index++;
        }
 
        if (row_index != 0)
        {
            ui->SoftwareLicenceList->setCurrentText(licence_name);
            licence_enabled = false;
        }
    }
    ui->SoftwareLicenceList->setEnabled(licence_enabled);
}
 
void LicenceManager::ProcessDocumentationRestriction(int DocumentationRestriction)
{
    bool licence_enabled = true;
 
    // Check if there is No Documentation ERestriction
    if (DocumentationRestriction != 0)
    {
        QString licence_name;
        QSqlDatabase db = QSqlDatabase::database();
        int row_index = 0;
        QSqlQuery licence_restriction_query(QString("select short_name from licence where licence_index = %1").arg(QString::number(DocumentationRestriction)));
        while ( licence_restriction_query.next() )
        {
            licence_name = licence_restriction_query.value(0).toString();
            row_index++;
        }
 
        if (row_index != 0)
        {
            ui->DocumentationLicenceList->setCurrentText(licence_name);
        }
    }
    ui->DocumentationLicenceList->setEnabled(licence_enabled);
}
 
void LicenceManager::ProcessHardwareRestriction(int HardwareRestriction)
{
        bool licence_enabled = true;
 
    // Check if there is No Documentation Restriction
    if (HardwareRestriction != 0)
    {
        QString licence_name;
        QSqlDatabase db = QSqlDatabase::database();
        int row_index = 0;
        QSqlQuery licence_restriction_query(QString("select short_name from licence where licence_index = %1").arg(QString::number(HardwareRestriction)));
        while ( licence_restriction_query.next() )
        {
            licence_name = licence_restriction_query.value(0).toString();
            row_index++;
        }
 
        if (row_index != 0)
        {
            ui->HardwareLicenceList->setCurrentText(licence_name);
        }
    }
    ui->HardwareLicenceList->setEnabled(licence_enabled);
}
 
void LicenceManager::ReadLicenceState(LICENCE_STATE LicenceState)
{
    ProcessSoftwareRestriction(LicenceState.SoftwareLicence);
    ProcessDocumentationRestriction(LicenceState.DocumentationLicence);
    ProcessHardwareRestriction(LicenceState.HardwareLicence);
}
 
void LicenceManager::WriteLicenceState(void)
{
    LICENCE_STATE project_licences;
    project_licences.SoftwareLicence = GetLicenceIndex(ui->SoftwareLicence->text());
    project_licences.DocumentationLicence = GetLicenceIndex(ui->SoftwareLicence->text());
    project_licences.HardwareLicence = GetLicenceIndex(ui->HardwareLicence->text());
    emit SendLicenceState(project_licences);
}
 
uint LicenceManager::GetLicenceIndex(QString LicenceText)
{
    uint licence_index = 0;
    QSqlQuery licence_index_query( QString("select licence_index from licence where short_name = '%1'").arg(LicenceText));
    while ( licence_index_query.next() )
    {
        licence_index = licence_index_query.value(0).toInt();
    }
    return(licence_index);
}
 
void LicenceManager::TriggerSendLicence(void)
{
    LogAdd(LOG_DEBUG, MODE_QT, "Request to Send Licences Received.");
    WriteLicenceState();
}
 
void LicenceManager::DoClear(void)
{
    LoadLicences();
}
 
void LicenceManager::SetSoftwareLicence(int LicenceIndex)
{
    QString LicenceName = ui->SoftwareLicenceList->itemText(LicenceIndex);
    emit UpdateSoftwareLicence(LicenceName);
}
 
void LicenceManager::SetHardwareLicence(int LicenceIndex)
{
    QString LicenceName = ui->HardwareLicenceList->itemText(LicenceIndex);
    emit UpdateHardwareLicence(LicenceName);
}
 
void LicenceManager::SetDocumentationLicence(int LicenceIndex)
{
    QString LicenceName = ui->DocumentationLicenceList->itemText(LicenceIndex);
    emit UpdateDocumentationLicence(LicenceName);
}