programversion.cpp

Go to the documentation of this file.

#include "programversion.h"
#include <QDateTime>
#include <QSqlQuery>
#include "common_definitions.h"
#include "projectdocmanager.h"
 
extern ProjectDocManager* project_doc_manager;
 
ProgramVersion::ProgramVersion(Ui::MainWindow* UI_Window)
{
    ui = UI_Window;
 
    timestamp_format_string = DATETIME_DISPLAY_FORMAT;
 
    QObject::connect( ui->MajorVersion, QOverload<int>::of(&QSpinBox::valueChanged), [=](quint16 i){ SetMajorVersion(i); });
    QObject::connect( ui->MinorVersion, QOverload<int>::of(&QSpinBox::valueChanged), [=](quint16 i){ SetMinorVersion(i); });
    QObject::connect( ui->Revision,     QOverload<int>::of(&QSpinBox::valueChanged), [=](quint16 i){ SetRevision(i); });
    QObject::connect( ui->OverrideStepControl, SIGNAL(stateChanged(int)), this, SLOT(SetStepOverride(int)));
    QObject::connect( ui->MajorVersion, SIGNAL(valueChanged(int)), this, SLOT(UpdateMajorVersion(int)));
    QObject::connect( ui->MinorVersion, SIGNAL(valueChanged(int)), this, SLOT(UpdateMinorVersion(int)));
    QObject::connect( ui->Revision,     SIGNAL(valueChanged(int)), this, SLOT(UpdateRevision(int)));
    QObject::connect(ui->UpdateVersion, SIGNAL(pressed()), this, SLOT(SaveVersion()));
    QObject::connect(ui->ProjectStatusDate, SIGNAL(dateTimeChanged(QDateTime)), this, SLOT(ReadProjectDateTime(QDateTime)));
}
 
void ProgramVersion::SetMajorVersion( quint16 Value )
{
    if ( ui->OverrideStepControl->isChecked() )
    {
        ui->MajorVersion->setMinimum( 0 );
        ui->MajorVersion->setMaximum( 999 );
        ui->MajorVersion->setValue(Value);
    }
    else
    {
        ui->MajorVersion->setMinimum( Value );
        ui->MajorVersion->setMaximum( Value + 1 );
        PresetMinorVersion( 0 );
    }
    ReadVersionText(project_index, version_info);
}
 
void ProgramVersion::SetMinorVersion( quint16 Value )
{
    if ( ui->OverrideStepControl->isChecked() )
    {
        ui->MinorVersion->setMinimum( 0 );
        ui->MinorVersion->setMaximum( 999 );
        ui->MinorVersion->setValue(Value);
    }
    else
    {
        ui->MinorVersion->setMinimum( Value);
        ui->MinorVersion->setMaximum( Value + 1 );
        PresetRevision( 0 );
    }
    ReadVersionText(project_index, version_info);
}
 
void ProgramVersion::SetRevision( quint16 Value )
{
    if ( ui->OverrideStepControl->isChecked() )
    {
        ui->Revision->setMinimum( 0);
        ui->Revision->setMaximum( 999 );
        ui->Revision->setValue(Value);
    }
    else
    {
        ui->Revision->setMinimum( Value );
        ui->Revision->setMaximum( Value + 1 );
    }
    ReadVersionText(project_index, version_info);
}
 
void ProgramVersion::PresetMajorVersion( quint16 Value )
{
    ui->MajorVersion->setMinimum( 0 );
    ui->MajorVersion->setMaximum( 999 );
    ui->MajorVersion->setValue( Value );
    SetMajorVersion( Value );
}
 
void ProgramVersion::PresetMinorVersion( quint16 Value )
{
    ui->MinorVersion->setMinimum( 0 );
    ui->MinorVersion->setMaximum( 999 );
    ui->MinorVersion->setValue( Value );
    SetMinorVersion( Value );
}
 
void ProgramVersion::PresetRevision( quint16 Value )
{
    ui->Revision->setMinimum( 0 );
    ui->Revision->setMaximum( 999 );
    ui->Revision->setValue( Value );
    SetRevision( Value );
}
 
void ProgramVersion::SetStepOverride( int State )
{
    QString message = "Operator set Version Step Override to ";
    if ( State == Qt::Checked )
    {
        ui->MajorVersion->setMinimum( 0 );
        ui->MajorVersion->setMaximum( 999 );
 
        ui->MinorVersion->setMinimum( 0 );
        ui->MinorVersion->setMaximum( 999 );
 
        ui->Revision->setMinimum( 0 );
        ui->Revision->setMaximum( 999 );
 
        LogAdd(LOG_DEBUG, MODE_OPERATOR, message + "ON.");
    }
    else
    {
        ui->MajorVersion->setMinimum( ui->MajorVersion->value() );
        ui->MajorVersion->setMaximum( ui->MajorVersion->value() + 1 );
 
        ui->MinorVersion->setMinimum( ui->MinorVersion->value() );
        ui->MinorVersion->setMaximum( ui->MinorVersion->value() + 1 );
 
        ui->Revision->setMinimum( ui->Revision->value() );
        ui->Revision->setMaximum( ui->Revision->value() + 1 );
 
        LogAdd(LOG_DEBUG, MODE_OPERATOR, message + "OFF.");
        SetVersionDate();
    }
}
 
void ProgramVersion::SetOverrideEnable(bool Enable)
{
    ui->OverrideStepControl->setChecked(Enable);
}
 
void ProgramVersion::ReadProjectInfo(PROJECT_INFORMATION* ProjectId)
{
    project_index = ProjectId->ProjectDesc.ProjectIndex;
    version_info = ProjectId->VersionInfo;
    PresetMajorVersion(ProjectId->VersionInfo.MajorVersion);
    PresetMinorVersion(ProjectId->VersionInfo.MinorVersion);
    PresetRevision(ProjectId->VersionInfo.Revision);
    QString version_timestamp = ProjectId->VersionInfo.VersionDate.toLocalTime().toString(timestamp_format_string);
    ui->VersionDate->setText(version_timestamp);
    ReadVersionText(project_index, ProjectId->VersionInfo);
}
 
REMOTE_VERSION_ENTRY ProgramVersion::WriteVersion(uint ProjectId)
{
    REMOTE_VERSION_ENTRY result;
    result.ProjectNumber = ProjectId;
    result.VersionInfo.MajorVersion = ui->MajorVersion->value();
    result.VersionInfo.MinorVersion = ui->MinorVersion->value();
    result.VersionInfo.Revision = ui->Revision->value();
    result.VersionInfo.FullVersionString = FormatVersion(result.VersionInfo.MajorVersion, result.VersionInfo.MinorVersion, result.VersionInfo.Revision);
    result.VersionInfo.VersionDate = QDateTime::fromString(ui->VersionDate->text(), timestamp_format_string );
    result.VersionInfo.VersionString = ui->VersionDescription->toPlainText();
    return( result );
}
 
void ProgramVersion::SetVersionDate(void)
{
    QString now = QDateTime::currentDateTime().toString(timestamp_format_string);
    ui->VersionDate->setText(now);
    if (!ui->OverrideStepControl->isChecked()) LogProgramVersion(WriteVersion(project_index));
    ui->VersionDescription->clear();
}
 
void ProgramVersion::LogAdd(LOGGING_SEVERITY Severity, LOGGING_MODE Mode, QString Message)
{
    REMOTE_LOG_ENTRY log_entry;
    log_entry.Severity = Severity;
    log_entry.Mode = Mode;
    log_entry.Message = Message;
    emit SendLogEntry(log_entry);
}
 
void ProgramVersion::LogProgramVersion(REMOTE_VERSION_ENTRY VersionInstance)
{
    QString version_timestamp_string = VersionInstance.VersionInfo.VersionDate.toString(timestamp_format_string);
    QString message_template = "Program Version is %1, dated %2";
    QString log_message = message_template.arg(VersionInstance.VersionInfo.FullVersionString, version_timestamp_string);
    LogAdd(LOG_DEBUG, MODE_OPERATOR, log_message);
}
 
void ProgramVersion::DoClear(void)
{
    SetOverrideEnable(true);
    SetMajorVersion(0);
    SetMinorVersion(0);
    SetRevision(0);
    SetVersionDate();
    ui->VersionDescription->clear();
    ui->ExecutableDirectory->clear();
    ui->FullHistory->clear();
    SetOverrideEnable(false);
}
 
void ProgramVersion::ReadVersionText(uint ProjectIndex, VERSION_INFO VersionInstance)
{
    QString p1 = QString::number(ProjectIndex);
    QString p2 = QString::number(VersionInstance.MajorVersion);
    QString p3 = QString::number(VersionInstance.MinorVersion);
    QString p4 = QString::number(VersionInstance.Revision);
    QString query_template = QString("select description, version_timestamp from proj_version_info where project_id = %1 and major_version = %2 and minor_version = %3 and revision = %4 ");
    QString query_string = query_template.arg(p1, p2, p3,p4);
    QSqlQuery version_text_query(query_string);
 
    while (version_text_query.next())
    {
        QString version_string = version_text_query.value(0).toString();
        ui->VersionDescription->setText(version_string);
        QDateTime version_datetime = version_text_query.value(1).toDateTime();
        ui->VersionDate->setText(version_datetime.toLocalTime().toString());
    }
 
    ReadFullHistory(ProjectIndex);
}
 
void ProgramVersion::SaveVersion(void)
{
    bool new_version = false;
 
    // Get the Version Data
    REMOTE_VERSION_ENTRY version = WriteVersion(project_index);
    QString p1 = QString::number(project_index);
    QString p2 = QString::number(ui->MajorVersion->value());
    QString p3 = QString::number(ui->MinorVersion->value());
    QString p4 = QString::number(ui->Revision->value());
    QString p5 = ui->VersionDescription->toPlainText();
    QString p6 = ui->ProjectStatus->currentText();
    QDateTime p7 = QDateTime::currentDateTime();
    ui->VersionDate->setText(p7.toString());
    // First Check if the Version Exists Already
    QString query_string = QString("select project_id from proj_version_info where project_id = %1 and major_version = %2 and minor_version = %3 and revision = %4").arg(p1, p2, p3, p4);
    QSqlQuery does_version_exist(query_string);
 
    // If the Version Exists Update the Version's Description.
    if (does_version_exist.next())
    {
        query_string = QString("update proj_version_info set description = '%1', version_status = '%5' where project_id = %2 and major_version = %3 and minor_version = %4 and revision = %5").arg(p5, p1, p2, p3, p4);
        QSqlQuery update_version_description(query_string);
        if (!update_version_description.exec()) LogAdd(LOG_ERROR, MODE_DATABASE, QString("ERROR - Unable to update Version %1.%2.%3").arg(p2, p3, p4, p5));
        else  LogAdd(LOG_DEBUG, MODE_DATABASE, QString("Update Version %1.%2.%3, Descrip: %p4, Status Level: %p5").arg(p1, p2, p3, p4, p5));
    }
 
    // No, It Doesn't, so make New Entry.
    else
    {
        // First Update the Project's Version so that it Database Constraints aren't violated
        query_string = QString("update project set major_version = %1, minor_version = %2, revision = %3 where project_index = %4").arg(p2, p3, p4, p1);
        QSqlQuery update_version_query;
        bool result = update_version_query.exec(query_string);
        if (!result)
        {
            LogAdd(LOG_ERROR, MODE_DATABASE, "ERROR - Unable to update Project Version during Version Update");
        }
        else
        {
            query_string =
                QString("INSERT INTO proj_version_info(project_id, major_version, minor_version, revision, description, version_status, version_timestamp) VALUES (%1, %2, %3, %4, '%5', '%6', '%7')").arg(p1, p2, p3, p4, p5, p6, p7.toString(DATETIME_DATABASE_FORMAT));
            QSqlQuery insert_version_query;
            result = insert_version_query.exec(query_string);
            if (!result) LogAdd(LOG_ERROR, MODE_DATABASE, "ERROR - Unable to insert Version Description!");
            else
            {
                LogAdd(LOG_DEBUG, MODE_DATABASE, QString("Inserted Version %1.%2.%3 Description").arg(p2, p3, p4));
                new_version = true;
            }
        }
    }
    version.VersionInfo.FullVersionString = ReadFullHistory(project_index);
 
    // If This is a New Version, Check if it should be committed to Git
    if (new_version) emit SendVersionInfo(version);
}
 
void ProgramVersion::UpdateMajorVersion(int MajorVersion)
{
    SetVersionDate();
    emit SendMajorVersion(MajorVersion);
}
 
void ProgramVersion::UpdateMinorVersion(int MinorVersion)
{
    SetVersionDate();
    emit SendMinorVersion(MinorVersion);
}
 
void ProgramVersion::UpdateRevision(int Revision)
{
    SetVersionDate();
    emit SendRevision(Revision);
}
 
void ProgramVersion::ReadProjectDateTime(QDateTime ProjectDateTime)
{
   emit SendProjectDateTime(ProjectDateTime.toString(timestamp_format_string));
}
 
QString ProgramVersion::FormatVersion(int MajorVersion, int MinorVersion, int Revision)
{
    return(QString::number(MajorVersion).rightJustified(2, '0') + "." +
           QString::number(MinorVersion).rightJustified(2, '0') + "." +
           QString::number(Revision).rightJustified(2, '0')
          );
}
 
QString ProgramVersion::ReadFullHistory(int ProjectIndex)
{
    QString full_history;
    QString query_string = QString("select major_version, minor_version, revision, description, version_status from proj_version_info where project_id = %1 order by major_version desc, minor_version desc, revision desc")
                                    .arg(QString::number(ProjectIndex));
    QSqlQuery version_text_query(query_string);
 
    while (version_text_query.next())
    {
        full_history += QString("<P><B>Version ") + FormatVersion(version_text_query.value(0).toInt(), version_text_query.value(1).toInt(), version_text_query.value(2).toInt()) + ": <I>";
        full_history += version_text_query.value(4).toString() + " </I></B>";
        full_history += version_text_query.value(3).toString() + "</P>";
    }
    ui->FullHistory->setText(full_history);
 
    return(full_history);
}