readprojectinfo.cpp

Go to the documentation of this file.

#include <QSqlQuery>
#include <QProcess>
 
#include "readprojectinfo.h"
 
extern int current_locked_project;
 
ReadProjectInfo::ReadProjectInfo(QObject *parent)
    : QObject{parent}
{
 
}
 
bool ReadProjectInfo::LoadProjectInfo(PROJECT_INFORMATION* Store, int ProjectIndex, int ProgramIndex)
{
    bool result = false;
    QString query_string = QString("select * from project where project_index = %1").arg(QString::number(ProjectIndex));
 
    QSqlQuery project_query(query_string);
    while ( project_query.next() )
    {
        Store->ProjectDesc.ProjectIndex                       = project_query.value(PT_PROJECT_INDEX).toInt();           // Project Index
        Store->ProjectDesc.ProjectName                        = project_query.value(PT_PROJECT_NAME).toString();        // Prject Name
        Store->VersionInfo.MajorVersion                       = project_query.value(PT_MAJOR_VERSION).toInt();           // Major Version
        Store->VersionInfo.MinorVersion                       = project_query.value(PT_MINOR_VERSION).toInt();           // Minor Version
        Store->VersionInfo.Revision                           = project_query.value(PT_REVISION).toInt();           // Revision Level
        Store->VersionInfo.VersionString                      = FormatVersion(Store->VersionInfo.MajorVersion, Store->VersionInfo.MinorVersion, Store->VersionInfo.Revision); // Version Numbes as String
        LoadVersionInfo(&Store->VersionInfo, ProjectIndex);                                                         // Text of the Current Version
        LoadFullHistory(&Store->VersionInfo, ProjectIndex);                                                         // Full Version History
        Store->ProjectDesc.BriefDescription                   = project_query.value(PT_BRIEF_DESCRIPTION).toString();        // Brief Description
        LoadDevFamilyData(&Store->DevFamilyInfo, project_query.value(PT_DEV_FAMILY).toInt());                         // Development Family
        LoadLangFamilyData(&Store->LangFamilyInfo, project_query.value(PT_COMPILER_FAMILY).toInt());                       // Computer Language Familt
        LoadStatusInfo(&Store->StatusInfo, project_query.value(PT_PROJECT_STATUS).toInt());                               // Status Level
 
        Store->ProjectLock                                    = project_query.value(PT_PROJECT_LOCK).toBool();          // Project Lock Satus
        LoadCompilerFamilyData(&Store->CompFamilyInfo, project_query.value(PT_COMPILER_TYPE).toInt());                   // Compiler Type
        Store->StatusInfo.StatusDateTime                      = project_query.value(PT_STATUS_DATE).toDateTime();      // Status Data Time
        Store->StatusInfo.StatusDateTimeString                = Store->StatusInfo.StatusDateTime.toString(DATETIME_DISPLAY_FORMAT); // Status DateTime as a String
        LoadLicenceData(&Store->DocLicence, project_query.value(PT_DOC_LICENCE).toInt());                              // Documentation Licence
        LoadLicenceData(&Store->SoftwareLicence, project_query.value(PT_SOFTWARE_LICENCE).toInt());                         // Software Licence
        LoadLicenceData(&Store->HardwareLicence, project_query.value(PT_HARDWARE_LICENCE).toInt());                         // Hardware Licence
        LoadDeveloperData(&Store->Developer, project_query.value(PT_PROJECT_CONTACT).toInt());                             // Contact Developer
        Store->ProjectDesc.FullDescription                    = project_query.value(PT_FULL_DESCRIPTION).toString();        // Full Description
        Store->ProjectDesc.ProjectDirectory                   = project_query.value(PT_PROJECT_DIRECTORY).toString();        // Project Directory
        Store->ProjectDesc.ProjectIcon                        = project_query.value(PT_ICON_FILENAME).toString();        // Project Icon
        Store->ProjectDesc.ProjectOptions                     = project_query.value(PT_PROJECT_OPTIONS).toUInt();          // Project Options
        Store->ProjectDesc.ProjectIdent                       = project_query.value(PT_PROJECT_IDENT).toString();        // Project Identification String
        Store->DoxyOptions.DoxyLogoFilename                   = project_query.value(PT_DOXY_PROJECT_LOGO_FILENAME).toString();        // Doxy Project Logo Image
        Store->DoxyOptions.DoxyHtmlHeaderFilename             = project_query.value(PT_DOXY_HTML_HEADER_FILENAME).toString();        // Doxy Project Header File
        Store->DoxyOptions.DoxyHtmlFooterFilename             = project_query.value(PT_DOXY_HTML_FOOTER_FILENAME).toString();        // Doxy Project Footer File
        Store->DoxyOptions.DoxyExtraStylesheetFilename        = project_query.value(PT_DOXY_EXTRA_STYLESHEET_FILENAME).toString();        // Doxy Project Extra Stylesheet Filename
        LoadAssocGroupData(&Store->InAssocInfo, project_query.value(PT_ASSOC_GROUP).toInt());                          // Associated Group Index
        Store->ProjectDesc.DepartureURL                       = project_query.value(PT_DEPARTURE_URL).toString();        // Departure URL
        Store->ProjectDesc.ExeDirectory                       = project_query.value(PT_EXECUTABLE_DIRECTORY).toString();        // Built Executable Directory
        Store->ProjectDesc.ExeName                            = project_query.value(PT_EXECUTABLE_NAME).toString();          // Built Executable Name
        Store->ProjectQueued                                  = project_query.value(PT_PROJECT_QUEUED).toBool();          // Read the Queued Flag
        LoadTargetFamilyData(&Store->TargetFamilyInfo, project_query.value(PT_TARGET_FAMILY).toInt());                   // target Family
 
        result = true;
    }
    if (result) LogAdd(LOG_DEBUG, MODE_DATABASE, "Project Data Loaded from Database"); else LogAdd(LOG_ERROR, MODE_DATABASE, "Project Data NOT Loaded from Database");
 
    // Load the Program level Data
    query_string = QString("select * from project_manager where proj_manager_index = %1").arg(QString::number(ProgramIndex));
 
    QSqlQuery program_query(query_string);
    bool result1 = false;
    while ( program_query.next() )
    {
        Store->ProgramInformation.ProgramInformationIndex       = program_query.value(PM_PROJ_MANAGER_INDEX).toInt();
        Store->ProgramInformation.SiteName                      = program_query.value(PM_SITE_NAME).toString();
        Store->ProgramInformation.SiteURL                       = program_query.value(PM_SITE_URL).toString();
        Store->ProgramInformation.SiteLogo                      = program_query.value(PM_SITE_LOGO).toString();
        Store->ProgramInformation.SharedTemplateDirectory       = program_query.value(PM_SHARED_TEMPLATE_DIR).toString();
        Store->ProgramInformation.LocalDevelopmentDirectory     = program_query.value(PM_LOCAL_DEV_DIRECTORY).toString();
        Store->ProgramInformation.ProjectPrefix                 = program_query.value(PM_PROJECT_PREFIX).toString();
        Store->ProgramInformation.SuffixSize                    = program_query.value(PM_SUFFIX_SIZE).toInt();
        Store->ProgramInformation.PrimaryWebsiteDirectory       = program_query.value(PM_PRIMARY_WEBSITE_DIRECTORY).toString();
        Store->ProgramInformation.PublisherName                 = program_query.value(PM_PUBLISHER_NAME).toString();
        Store->ProgramInformation.PublisherWebsite              = program_query.value(PM_PUBLISHER_WEBSITE).toString();
        Store->ProgramInformation.PublisherContactEmail         = program_query.value(PM_PUBLISHER_CONTACT_EMAIL).toString();
        Store->ProgramInformation.ProjectListHeaderFilename     = program_query.value(PM_PROJECT_LIST_HEADER_FILENAME).toString();
        Store->ProgramInformation.ProjectListFooterFilename     = program_query.value(PM_PROJECT_LIST_FOOTER_FILENAME).toString();
        Store->ProgramInformation.ProjectListLineFilename       = program_query.value(PM_PROJECT_LIST_LINE_FILENAME).toString();
        Store->ProgramInformation.DefaultReturnAddress          = program_query.value(PM_PROJECT_LIST_RETURN_ADDRESS).toString();
        Store->ProgramInformation.DevelopmentDoxyDocDirectory   = program_query.value(PM_PROJECT_DEVELOPMENT_DOXY_DIRECTORY).toString();
        result1 = true;
    }
    Store->ProgramInformation.CurrentUser = qgetenv("USER");
    if (result1) LogAdd(LOG_DEBUG, MODE_DATABASE, "Program Data Loaded from Database"); else LogAdd(LOG_ERROR, MODE_DATABASE, "Program Data NOT Loaded from Database");
    return(result && result1);
}
 
bool ReadProjectInfo::LoadLicenceData(LICENCE_INFO* Licence, int LicenceIndex)
{
    bool result = false;
    QString query_string = QString("select * from licence where licence_index = %1").arg(QString::number(LicenceIndex));
 
    QSqlQuery licence_query(query_string);
    int row_index = 0;
    while ( licence_query.next() )
    {
        Licence->LicenceIndex = licence_query.value(row_index++).toInt();
        Licence->ShortName    = licence_query.value(row_index++).toString();
        Licence->FullName     = licence_query.value(row_index++).toString();
        Licence->LicenceURL   = licence_query.value(row_index++).toString();
        Licence->LicenceImage = licence_query.value(row_index++).toString();
        result = true;
    }
    if (!result)
    {
        Licence->LicenceIndex = 0;
        Licence->ShortName    = "";
        Licence->FullName     = "";
        Licence->LicenceURL   = "";
        Licence->LicenceImage = "";
    }
    if (result) LogAdd(LOG_DEBUG, MODE_DATABASE, "Licence Data Loaded from Database"); else LogAdd(LOG_DEBUG, MODE_DATABASE, "Licence Data NOT Loaded from Database");
    return(result);
}
 
bool ReadProjectInfo::LoadAssocGroupData(ASSOCIATED_GROUP_INFO* Assoc, int AssociationIndex)
{
    bool result = false;
    QString query_string = QString("select * from in_association where in_assoc_index = %1").arg(QString::number(AssociationIndex));
 
    QSqlQuery assoc_query(query_string);
    int row_index = 0;
    while(assoc_query.next())
    {
        Assoc->InAssociationIndex = assoc_query.value(row_index++).toInt();
        Assoc->ShortName          = assoc_query.value(row_index++).toString();
        Assoc->FullName           = assoc_query.value(row_index++).toString();
        Assoc->AssociationURL     = assoc_query.value(row_index++).toString();
        Assoc->AssociationLogo    = assoc_query.value(row_index++).toString();
        Assoc->HtaccessFileName   = assoc_query.value(row_index++).toString();
        result = true;
    }
    if (!result)
    {
        Assoc->InAssociationIndex       = 0;
        Assoc->ShortName.clear();
        Assoc->FullName.clear();
        Assoc->AssociationURL.clear();
        Assoc->AssociationLogo.clear();
        Assoc->HtaccessFileName.clear();
    }
    if (result) LogAdd(LOG_DEBUG, MODE_DATABASE, "In Association Data Loaded from Database"); else LogAdd(LOG_DEBUG, MODE_DATABASE, "In Association Data NOT Loaded from Database");
    return(result);
}
 
bool ReadProjectInfo::LoadDevFamilyData(DEV_FAMILY_INFO* DevFam, int DevFamilyIndex)
{
    bool result = false;
    QString query_string = QString("select * from dev_family where dev_family_index = %1").arg(QString::number(DevFamilyIndex));
 
    QSqlQuery dev_fam_query(query_string);
    int row_index = 0;
    while(dev_fam_query.next())
    {
        DevFam->DevFamilyIndex = dev_fam_query.value(row_index++).toInt();
        DevFam->ShortName      = dev_fam_query.value(row_index++).toString();
        DevFam->FullName       = dev_fam_query.value(row_index++).toString();
        DevFam->DevFamilyImage = dev_fam_query.value(row_index++).toString();
        result = true;
 
    }
    if (!result)
    {
        DevFam->DevFamilyIndex           = 0;
        DevFam->ShortName                = "";
        DevFam->FullName                 = "";
        DevFam->DevFamilyImage           = "";
    }
    if (result) LogAdd(LOG_DEBUG, MODE_DATABASE, "Dev Family Data Loaded from Database"); else LogAdd(LOG_DEBUG, MODE_DATABASE, "Deve Family Data NOT Loaded from Database");
    return(result);
}
 
bool ReadProjectInfo::LoadLangFamilyData(LANG_FAMILY_INFO* LangFam, int LangFamilyIndex)
{
    bool result = false;
    QString query_string = QString("select * from compiler_family where comp_family_index = %1").arg(QString::number(LangFamilyIndex));
 
    QSqlQuery lang_fam_query(query_string);
    int row_index = 0;
    while(lang_fam_query.next())
    {
        LangFam->LangFamilyIndex = lang_fam_query.value(row_index++).toInt();
        LangFam->ShortName       = lang_fam_query.value(row_index++).toString();
        LangFam->FullName        = lang_fam_query.value(row_index++).toString();
        LangFam->LangFamilyImage = lang_fam_query.value(row_index++).toString();
        result = true;
 
    }
    if (!result)
    {
        LangFam->LangFamilyIndex           = 0;
        LangFam->ShortName                = "";
        LangFam->FullName                 = "";
        LangFam->LangFamilyImage           = "";
    }
    if (result) LogAdd(LOG_DEBUG, MODE_DATABASE, "Language Data Loaded from Database"); else LogAdd(LOG_DEBUG, MODE_DATABASE, "Language Data NOT Loaded from Database");
    return(result);
}
 
bool ReadProjectInfo::LoadTargetFamilyData(TARGET_FAMILY_INFO* TargetFam, int TargetFamilyIndex)
{
    bool result = false;
    QString query_string = QString("select * from target_family where target_family_index = %1").arg(QString::number(TargetFamilyIndex));
 
    QSqlQuery target_fam_query(query_string);
    int row_index = 0;
    while(target_fam_query.next())
    {
        TargetFam->TargetFamilyIndex = target_fam_query.value(row_index++).toInt();
        TargetFam->ShortName         = target_fam_query.value(row_index++).toString();
        TargetFam->FullName          = target_fam_query.value(row_index++).toString();
        TargetFam->TargetFamilyImage = target_fam_query.value(row_index++).toString();
        result = true;
 
    }
    if (!result)
    {
        TargetFam->TargetFamilyIndex        = 0;
        TargetFam->ShortName                = "";
        TargetFam->FullName                 = "";
        TargetFam->TargetFamilyImage        = "";
    }
    if (result) LogAdd(LOG_DEBUG, MODE_DATABASE, "Language Data Loaded from Database"); else LogAdd(LOG_DEBUG, MODE_DATABASE, "Language Data NOT Loaded from Database");
    return(result);
}
 
 
bool ReadProjectInfo::LoadCompilerFamilyData(COMP_FAMILY_INFO* CompFam, int CompFamilyIndex)
{
    bool result = false;
    QString query_string = QString("select * from compiler_instance where compiler_instance_index = %1").arg(QString::number(CompFamilyIndex));
 
    QSqlQuery compiler_fam_query(query_string);
    int row_index = 0;
    while(compiler_fam_query.next())
    {
        CompFam->CompFamilyIndex                 = compiler_fam_query.value(row_index++).toInt();
        CompFam->ShortName                       = compiler_fam_query.value(row_index++).toString();
        CompFam->FullName                        = compiler_fam_query.value(row_index++).toString();
        CompFam->CompilerToolImage               = compiler_fam_query.value(row_index++).toString();
        CompFam->CompilerDirectory               = compiler_fam_query.value(row_index++).toString();
        CompFam->SoftwareLicenceRestriction      = compiler_fam_query.value(row_index++).toInt();
        CompFam->DocumentationLicenceRestriction = compiler_fam_query.value(row_index++).toInt();
        CompFam->HardwareLicenceRestriction      = compiler_fam_query.value(row_index++).toInt();
        result = true;
    }
    if (!result)
    {
        CompFam->CompFamilyIndex                 = 0;
        CompFam->ShortName                       = "";
        CompFam->FullName                        = "";
        CompFam->CompilerToolImage               = "";
        CompFam->CompilerDirectory               = "";
        CompFam->SoftwareLicenceRestriction      = 0;
        CompFam->DocumentationLicenceRestriction = 0;
        CompFam->HardwareLicenceRestriction      = 0;
    }
    if (result) LogAdd(LOG_DEBUG, MODE_DATABASE, "Compiler Instance Data Loaded from Database"); else LogAdd(LOG_DEBUG, MODE_DATABASE, "Compiler Instance Data NOT Loaded from Database");
    return(result);
}
 
bool ReadProjectInfo::LoadVersionInfo(VERSION_INFO* Version, int ProjectIndex)
{
    bool result = false;
    QString query_string =
        QString("select description, version_timestamp from proj_version_info where project_id = %1 and major_version = %2 and minor_version = %3 and revision = %4")
                                .arg(QString::number(ProjectIndex), QString::number(Version->MajorVersion), QString::number(Version->MinorVersion), QString::number(Version->Revision));
    QSqlQuery version_text_query(query_string);
 
    while (version_text_query.next())
    {
        Version->CurrentVersionString = version_text_query.value(0).toString();
        Version->VersionDate = version_text_query.value(1).toDateTime();
        Version->VersionDateString = Version->VersionDate.toString(DATETIME_DISPLAY_FORMAT);
        result = true;
    }
    return(result);
}
 
bool ReadProjectInfo::LoadFullHistory(VERSION_INFO* Version, int ProjectIndex)
{
    bool result = false;
    QString query_string =
        QString("select major_version, minor_version, revision, description 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);
 
    Version->FullVersionString.clear();
 
    while (version_text_query.next())
    {
        Version->FullVersionString += QString("<P><B>Version <I>") +
                                      FormatVersion(version_text_query.value(0).toInt(), version_text_query.value(1).toInt(), version_text_query.value(2).toInt()) +
                                      ":</I></B><BR>" +
                                      version_text_query.value(3).toString() + "</P>\n";
        result = true;
    }
    return(result);
}
 
QString ReadProjectInfo::FormatVersion(int MajorVersion, int MinorVersion, int Revision)
{
    QString version_string = QString("%1.%2.%3")
                                .arg(QString::number(MajorVersion).rightJustified(2,'0'), QString::number(MinorVersion).rightJustified(2,'0'), QString::number(Revision    ).rightJustified(2,'0'));
    return(version_string);
}
 
bool ReadProjectInfo::LoadStatusInfo(STATUS_INFO* Status, int StatusIndex)
{
    bool result = false;
    QString query_string =
    QString("select * from project_status where proj_status_index = %1").arg(QString::number(StatusIndex));
    QSqlQuery status_query(query_string);
    int row_index = 0;
 
    while (status_query.next())
    {
        Status->StatusIndex       = status_query.value(row_index++).toInt();
        Status->StatusName        = status_query.value(row_index++).toString();
        Status->StatusDescription = status_query.value(row_index++).toString();
        Status->StatusImage       = status_query.value(row_index++).toString();
        result = true;
    }
    return(result);
}
 
bool ReadProjectInfo::LoadDeveloperData(DEVELOPER_INFO* person, int DevIndex)
{
    bool result = false;
    QString query_string =
        QString("select * from developer where developer_index = %1").arg(QString::number(DevIndex));
    QSqlQuery dev_query(query_string);
    int row_index = 0;
 
    while (dev_query.next())
    {
        person->DeveloperIndex = dev_query.value(row_index++).toInt();
        person->Name           = dev_query.value(row_index++).toString();
        person->Email          = dev_query.value(row_index++).toString();
        person->Phone          = dev_query.value(row_index++).toString();
        person->Info           = dev_query.value(row_index++).toString();
        person->IsAvailable    = dev_query.value(row_index++).toBool();
        person->Handle         = dev_query.value(row_index++).toString();
        person->DateJoined     = dev_query.value(row_index++).toDateTime();
        person->DateLeft       = dev_query.value(row_index++).toDateTime();
        result = true;
    }
    return(result);
}
 
void ReadProjectInfo::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);
}
 
bool ReadProjectInfo::SetProjectStatus(int ProjectIndex, bool LockState, bool QueueState)
{
    bool result;
    QString set_command_string = QString("UPDATE project SET ")
                                 + "  project_lock   = " + QVariant(LockState).toString()
                                 + ", project_queued = " + QVariant(QueueState).toString()
                                 + "  where project_index = " + QString::number(ProjectIndex);
 
    QSqlQuery update_query;
    result = update_query.exec(set_command_string);
 
    if (result)
    {
        if (LockState) current_locked_project = ProjectIndex; else current_locked_project = 0;
        LogAdd(LOG_DEBUG, MODE_DATABASE, QString("Project with Index: %1 set its Lock/Queque Status.").arg(ProjectIndex) );
 
    }
    else
    {
        LogAdd(LOG_ERROR, MODE_DATABASE, QString("Project with Index: %1 did NOT set its Lock/Queque Status.").arg(ProjectIndex) );
    }
    return(result);
}