worker.cpp

Go to the documentation of this file.

#include "worker.h"
#include "projectoptionsmanager.h"
#include "readprojectinfo.h"
#include <QProcess>
#include <QSqlQuery>
 
extern ProjectOptionsManager* project_opts_manager;
 
Worker::Worker (QObject *parent)
    : QObject{ parent }, leadin_string ("[#"), leadout_string ("#]")
{
    // Define the List of Source Directories of Containing Possible Documentation or Source Files
    // Documentation files are composed exclussively of .dox files along with .dia files and .uml
    // files.
 
    docs_filter   << "*.dox" << "Doxyfile" << "footer.html" << "header.html" << "customdoxygen.css" << "*.dia" << "*.uml" << "*.txt" << "*.pdf" << "*.doc" << "*.docx" << "*.tcw" << "*.tct" << "*.dwg" ;
 
    source_dirs << "/autoinstall/" << "/autosrc/";
    source_filter << "*.c" << "*.cpp" << "*.h" << ".hpp" << "*.ui" << "*.pro" << "*.pro.user" << "*.qrc" << "*.php" << "*.php" << "*.php4" << "*.php5" << "*.py" << "*.f" << "*.for" << "*.js" << "*.sh" << "*.sql";
 
    all_filter << "*";
}
 
void
Worker::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 Worker::DoWork(PROJECT_INFORMATION* ProjectInfo)
{
    LogAdd( LOG_INFO, MODE_THREAD, QString("Project %1 documentation processing started in Thread.").arg(ProjectInfo->ProjectDesc.ProjectIdent) );
    docs_dirs.clear(); docs_dirs << "defaults";
    autodoc_dir = "/autodocs/";
 
    switch (ProjectInfo->TargetFamilyInfo.TargetFamilyIndex)
    {
        case TARGET_NOT_DEFINED:
            autodoc_dir += "not_defined";
        break;
 
        case TARGET_OPEN_SIM_PROJECT:
            autodoc_dir += "open_sim_project";
        break;
 
        case TARGET_OPEN_SIM_SCRIPT:
            autodoc_dir += "open_sim_script";
        break;
 
        case TARGET_SOFTWARE:
            autodoc_dir += "software";
        break;
 
        case TARGET_HARDWARE:
            autodoc_dir += "hardware";
        break;
 
        case TARGET_DEVELOPMENT:
            autodoc_dir += "development";
        break;
 
        case TARGET_DOCUMENTATION:
            autodoc_dir += "documentation";
        break;
    }
    docs_dirs << autodoc_dir << source_dirs;
 
    if (PreProcessProject(ProjectInfo))
    {
        DoDoxygen(ProjectInfo);
    }
 
    // Create the Source Archive
    if (project_opts_manager->CheckCreateSourceArchive(ProjectInfo->ProjectDesc.ProjectOptions))
    {
        CreateSourceArchive(ProjectInfo);
    }
 
    // Create the Publish List
    if (project_opts_manager->CheckCreatePublishList (
            ProjectInfo->ProjectDesc.ProjectOptions))
      {
        CreatePublishList (ProjectInfo);
      }
 
    // Create the Installation Script, if required
    if (project_opts_manager->CheckAutomaticInstall(ProjectInfo->ProjectDesc.ProjectOptions))
    {
        CreateInstallScript(ProjectInfo);
    }
 
    // Finish Off
    LogAdd( LOG_INFO, MODE_THREAD, QString("Project %1 documentation processing ended in Thread.").arg(ProjectInfo->ProjectDesc.ProjectIdent) );
    emit WorkDone (ProjectInfo);
}
 
void Worker::DoDoxygen(PROJECT_INFORMATION* ProjectInfo)
{
    QString project_ident = ProjectInfo->ProjectDesc.ProjectIdent;
    // Generate the Doxygen Documentation
    QProcess doxygen;
    doxygen.start("doxygen", QStringList() << ProjectInfo->ProjectDesc.ProjectDirectory + "/source/" + ProjectInfo->ProjectDesc.ExeName + QString( "/Doxyfile" ) );
 
    if (!doxygen.waitForStarted())
    {
        LogAdd( LOG_ERROR, MODE_THREAD, QString("Doxygen did NOT Start for Project %1.").arg(project_ident) );
    }
    else
    {
        LogAdd( LOG_DEBUG, MODE_THREAD, QString("Started Doxygen Process for Project %1.").arg(project_ident) );
    }
 
    doxygen.closeWriteChannel();
    if (!doxygen.waitForFinished( 480000 ))        // Maximum of 8 minutes.
    {
        LogAdd( LOG_ERROR, MODE_THREAD, QString("Doxygen did NOT end for Project %1.").arg(project_ident) );
        ProjectInfo->ExecutionStatus = EXECUTION_FAILURE;
    }
    else
    {
        // Copy the Doxygen Log File into the Web Directory for Later Use.
        QString source_file    = ProjectInfo->ProjectDesc.ProjectDirectory + "/scratch/" + DOXY_LOG_FILE;
        QString dest_directory = ProjectInfo->ProgramInformation.PrimaryWebsiteDirectory + "/projects/" + ProjectInfo->ProjectDesc.ProjectIdent + "/html/";
        QFile file(source_file);
        if (file.copy(dest_directory + DOXY_LOG_FILE))
        {
            LogAdd( LOG_DEBUG, MODE_THREAD, QString("Project %1 doxygen log file copied to web directory").arg(ProjectInfo->ProjectDesc.ProjectIdent));
        }
        else
        {
            LogAdd( LOG_ERROR, MODE_THREAD, QString("Project %1 doxygen log file NOT copied to web directory").arg(ProjectInfo->ProjectDesc.ProjectIdent));
        }
 
        LogAdd( LOG_DEBUG, MODE_THREAD, QString("Doxygen finished for Project %1.").arg(project_ident) );
 
        // Flag Success
        ProjectInfo->ExecutionStatus = EXECUTION_SUCCESS;
    }
}
 
 
QString Worker::UpdateLine( PROJECT_INFORMATION* Project, QString SourceLine )
{
    // Get the Map holding the Keys and Values
    QMap<QString, QString> subs_map = Project->SubsMap;
 
    // Scan the Line Looking for a valid key construction
    while(SourceLine.contains(leadin_string) && SourceLine.contains(leadout_string))
    {
        int key_start   = SourceLine.indexOf(leadin_string);
        int key_end     = SourceLine.indexOf(leadout_string) + 2;
        QString found_key   = SourceLine.sliced(key_start, (key_end - key_start));
        QString found_value = subs_map.value(found_key);
        SourceLine.replace(found_key, found_value);
    }
 
    // return the Updated Line
    return(SourceLine);
}
 
bool Worker::UpdateFile( PROJECT_INFORMATION* Project, QString SourceFile, QString DestinationFile )
{
    bool result = true;
 
    // Line Buffer
    //QString line; QString output_line;
 
    // If the Destination File Already Exists, Remove it.
    QFile output_file( DestinationFile );
 
    // Remove Existing File (If it exists)
    if ( output_file.remove() )
    {
        LogAdd( LOG_DEBUG, MODE_FILE, QString( "File " + DestinationFile + QString( " was removed." ) ) );
    }
    else
    {
        if (output_file.exists())
        {
            LogAdd( LOG_ERROR, MODE_FILE, QString( "File " + DestinationFile + QString( " was NOT removed." ) ) );
            result = false;
        }
        else
        {
            LogAdd( LOG_DEBUG, MODE_FILE, QString( "File " + DestinationFile + QString( " did not Exist." ) ) );
        }
    }
 
    // Update the Template File and Put into the Destination Location (If Possible)
    if (result)
    {
        if (output_file.open(QIODevice::ReadWrite))
        {
            QTextStream out( &output_file );
 
            QFile input_file( SourceFile );
            if (input_file.open(QIODevice::ReadOnly))
            {
                QTextStream in( &input_file );
 
                while (!in.atEnd())
                {
                    QString line = in.readLine();
                    QString output_line = UpdateLine(Project, line);
                    out << output_line << "\n";
                }
                input_file.close();
                output_file.close();
                LogAdd( LOG_DEBUG, MODE_FILE, QString( "Update of File " ) + SourceFile + " to " + DestinationFile + QString( " completed." ) );
                result = true;
            }
            else
            {
                LogAdd( LOG_ERROR, MODE_FILE, "Unable to Open Input " + SourceFile );
                result = false;
            }
        }
        else
        {
            LogAdd( LOG_ERROR, MODE_FILE, "Unable to Open Output " + DestinationFile );
            result = false;
        }
    }
    return( result );
}
 
bool Worker::TranslateRecursively(PROJECT_INFORMATION* Store, const QString &srcFilePath, const QString &tgtFilePath)
{
    // Check if the Source is a File or a Directory
    QFileInfo srcFileInfo(srcFilePath);
    if (srcFileInfo.isDir())
    {
        // If the Target Directory Doesn't Exist, Create It
        QDir targetDir(tgtFilePath);
        if ( !targetDir.exists() )
        {
            // Go Up a Level and Create the Directory
            targetDir.cdUp ();
            if (!targetDir.mkpath (QFileInfo (tgtFilePath).fileName ()))
              {
                return false;
              }
        }
 
        // Copy Each Entry in the Directory to the Target
        QDir sourceDir(srcFilePath);
        QStringList fileNames = sourceDir.entryList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot | QDir::Hidden | QDir::System);
        foreach (const QString &fileName, fileNames) {
            const QString newSrcFilePath
                = srcFilePath + QLatin1Char('/') + fileName;
            const QString newTgtFilePath
                = tgtFilePath + QLatin1Char('/') + fileName;
            if (!TranslateRecursively(Store, newSrcFilePath, newTgtFilePath))
            {
                return false;
            }
        }
    }
 
    // If it is a File Translate It
    else
    {
        if (!UpdateFile(Store, srcFilePath, tgtFilePath ))
        {
            LogAdd( LOG_ERROR, MODE_FILE, QString( "Error in file translation from '" ) + srcFilePath + QString("' to '") + tgtFilePath + "." );
            return false;
        }
    }
    return true;
}
 
bool Worker::PreProcessProject(PROJECT_INFORMATION* ProjectInfo)
{
    bool result = false;
 
    // Get ProjectData
    QString project_ident = ProjectInfo->ProjectDesc.ProjectIdent;
    QString source_directory = ProjectInfo->ProjectDesc.ProjectDirectory;
    QString destination_directory = ProjectInfo->ProgramInformation.PrimaryWebsiteDirectory + "/projects/" + project_ident;
    QString code_directory = source_directory + "/source/" + ProjectInfo->ProjectDesc.ExeName;
 
    // Don't touch it if the Project is Locked or Excluded by Option
    if (ProjectInfo->ProjectLock && !(ProjectInfo->ProjectDesc.ProjectOptions & EXCLUDE_PROJECT_LIST))
    {
        // Time to Clean out the Destination Directory
        CleanDirectory(destination_directory);
 
        QDir dir;
        if (!dir.mkpath(destination_directory + "/html"))
        {
            LogAdd( LOG_ERROR, MODE_FILE, QString("Default webpage directory for Project %1 was NOT created.").arg(project_ident));
        }
        else
        {
            // Check to See if Only the Default Page Should be Produced
            if ((ProjectInfo->ProjectDesc.ProjectOptions & CONTROL_DOC_ACCESS) && (ProjectInfo->ProjectDesc.ProjectOptions & ONLY_DEFAULT_PAGE))
            {
                   if (UpdateFile (ProjectInfo, source_directory + "/defaults/index.html", destination_directory + "/html/index.html"))
                    {
                        LogAdd( LOG_DEBUG, MODE_FILE, QString("Default webpage for Project %1 updated.").arg(project_ident));
                    }
                    else
                    {
                        LogAdd( LOG_ERROR, MODE_FILE, QString("Default webpage for Project %1 was NOT updated.").arg(project_ident));
                    }
            }
 
            // Otherwise Process the Entire Project using Doxygen
            else
            {
                // Trim the Code Directory
                TrimDirectory(code_directory, docs_filter);
 
                // Count the Number of Lines in the files in the Code Directory
                QString cloc_output = CountLines(ProjectInfo, code_directory);
                ProjectInfo->SubsMap.insert("[#CLOC_INFO#]", cloc_output);
 
                // Try to Find the Libraries that may be used by the Release Version of the Program
                QString ldd_output = FindLibraries(ProjectInfo);
                ProjectInfo->SubsMap.insert("[#LIBRARY_LIST#]", ldd_output);
 
                // Check the C++ Source Files
                QString cpp_check;
                if (ProjectInfo->LangFamilyInfo.LangFamilyIndex == 5) // Test if C++
                {
                    cpp_check = CppCheck( ProjectInfo );
                }
                else
                {
                    cpp_check = "Currently Only available for C/C++ language.";
                }
                ProjectInfo->SubsMap.insert("[#CPP_CHECK#]", cpp_check);
 
                // Update the Auto Source Files in the Code Directory
                QString dir_name = source_directory + "/autosrc";
                TranslateRecursively (ProjectInfo, dir_name, code_directory);
 
                // Translate the Auto Documentation Files into the Code Directory
                TranslateRecursively(ProjectInfo, source_directory + autodoc_dir, code_directory);
 
                // Translate the Doxy Files into the Code Directory
                TranslateRecursively(ProjectInfo, source_directory + "/doxy", code_directory);
 
                // Translate the Installation File Template
 
                //Transfer the Images into the Image Directory
                QString source_image_directory = source_directory + "/images";
                QString destination_image_directory = destination_directory + "/images";
                //CleanDirectory(destination_image_directory);
                if (RecursiveCopy(source_image_directory, destination_image_directory))
                {
                     LogAdd( LOG_DEBUG, MODE_FILE, QString("Image Directiory for Project %1 was updated.").arg(project_ident));
                }
                else
                {
                    LogAdd( LOG_ERROR, MODE_FILE, QString("Image Directiory for Project %1 was NOT updated.").arg(project_ident));
                }
 
                // Transfer the Documents into the Documentation Directory
                QString source_docs_directory = source_directory + "/docs";
                QString destination_docs_directory = destination_directory + "/docs";
                //CleanDirectory(destination_docs_directory);
 
                if (RecursiveCopy(source_docs_directory, destination_docs_directory))
                {
                    LogAdd( LOG_DEBUG, MODE_FILE, QString("Docs Directiory for Project %1 was updated.").arg(project_ident));
                }
                else
                {
                    LogAdd( LOG_ERROR, MODE_FILE, QString("Docs Directiory for Project %1 was NOT updated.").arg(project_ident));
                }
 
 
                // Send to the Worker
                result = true;
            }
        }
    }
    return(result);
}
 
bool Worker::CleanDirectory( QString Directory)
{
    bool result = false;
    // Check if the Directory Exists
    QDir dir(Directory);
 
    // Delete the Directory if it Exists
    if (dir.exists())
    {
        dir.removeRecursively();
    }
 
    // Recreate the Main Directory
    result = dir.mkpath(Directory);
 
    return(result);
}
 
bool Worker::TrimDirectory(QString Directory, QStringList FileFilter)
{
    bool result = true;
 
    // Check if the Directory Exists
    QDir dir(Directory);
 
    // Check the Directory Exists
    if (dir.exists())
    {
        // Get the Files in the Code Directory to Delete and Delete Them
        dir.setNameFilters(FileFilter);
        QStringList file_list = dir.entryList(QDir::Files | QDir::NoDotAndDotDot | QDir::NoSymLinks, QDir::NoSort);
        for (int index = 0; index < file_list.size(); ++index)
        {
            if (!dir.remove(file_list.at(index))) result = false;
        }
    }
    return(result);
}
 
QString Worker::CountLines(PROJECT_INFORMATION* Store, QString Directory)
{
    QString html_result_table = "<TABLE BORDER=1><TR><TH>Language</TH><TH>Files</TH><TH>Blank</TH><TH>Comment</TH><TH>Code</TH></TR>";
    QString html_result_rows = "";
    QString html_result_totals = "";
 
    QDir::setCurrent( Directory );
    // Get the Lines Of Code Information
    QProcess cloc;
    QString scratchdir = Store->ProgramInformation.LocalDevelopmentDirectory + "/" + Store->ProjectDesc.ProjectIdent + "/scratch/";
    QString output_file = scratchdir + "cloc_output.txt";
 
    cloc.setStandardErrorFile( scratchdir + "cloc_error.txt",  QIODevice::WriteOnly | QIODevice::Text  );
    cloc.setStandardOutputFile( scratchdir + "cloc_output.txt", QIODevice::WriteOnly | QIODevice::Text  );
    QStringList Arg;
    Arg << Directory << "--no-recurse";
    cloc.start( "cloc", QStringList() << Arg );
    if (!cloc.waitForStarted())
    {
        LogAdd( LOG_ERROR, MODE_THREAD, "cloc Process did NOT Start." );
        html_result_table += "<TR><TD COLSPAN=5>Unable to Count Lines of Code.</TD></TR>";
    }
    else
    {
        LogAdd( LOG_DEBUG, MODE_THREAD, QString( "Started cloc Process " ) );
    }
    if (!cloc.waitForFinished(100000))
    {
        LogAdd( LOG_ERROR, MODE_THREAD, "cloc Process did NOT End." );
        html_result_table += "<TR><TD COLSPAN=5>Error occurred during Count Lines of Code.</TD></TR>";
    }
    else
    {
        LogAdd( LOG_DEBUG, MODE_THREAD, "cloc Process finished." );
 
        // Read the Ouptut of the CLOC Program
        QFile cloc_file(output_file);
        if ( !cloc_file.open( QIODevice::ReadOnly | QIODevice::Text ) )
        {
            LogAdd( LOG_ERROR, MODE_FILE, "Unable to open cloc result file." );
            html_result_table += "<TR><TD COLSPAN=5>Error occurred reading cloc results.</TD></TR>";
        }
        else
        {
            int     comment_count = 0;
            QString text_line;
 
            while( !cloc_file.atEnd() )
            {
                text_line = cloc_file.readLine();
                if ( text_line.contains( "----", Qt::CaseInsensitive ) )
                {
                    comment_count++;
                }
                else
                {
                    // Process Column Headers
                    if ( comment_count == 1 )
                    {
                        QStringList tokens= text_line.split(" ",Qt::SkipEmptyParts);
 
                        html_result_table += "<TR><TD>" + tokens[0] + "</TD><TD>" + tokens[1] + "</TD><TD>" + tokens[2] + "</TD><TD>" +
                                             tokens[3] + "</TD><TD>" + tokens[4] + "</TD></TR>";
                    }
 
                    //Process Report Rows
                    else if ( comment_count == 2 )
                    {
 
                        QString language_name = text_line.first(25);
                        language_name = language_name.trimmed();
                        text_line = text_line.mid(25);
                        QStringList tokens= text_line.split(" ",Qt::SkipEmptyParts);
 
                        html_result_rows += "<TR><TD><B><span style=\"color:red\">" + language_name + "</span></B></TD><TD><B><span style=\"color:red\">" + tokens[0] +
                                            "</span></B></TD><TD><B><span style=\"color:red\">" + tokens[1] + "</span></B></TD><TD><B><span style=\"color:red\">" +
                                            tokens[2] + "</span></B></TD><TD><B><span style=\"color:red\">" + tokens[3] + "</span></B></TD></TR>";
                    }
                    else if (comment_count ==3)
                    {
                        QStringList tokens= text_line.split(" ",Qt::SkipEmptyParts);
 
                        html_result_totals = "<TR><TD><B>" + tokens[0] + "</B></TD><TD>" + tokens[1] + "</TD><TD>" + tokens[2] + "</TD><TD>" +
                                             tokens[3] + "</TD><TD>" + tokens[4] + "</TD></TR>";
                    }
                }
            }
        }
    }
 
    // Finish table and Return Result
    html_result_table += html_result_rows + html_result_totals + "</TABLE>";
 
    // Remove Scratch Files
    QFile::remove(Store->ProgramInformation.LocalDevelopmentDirectory + "cloc_error.txt"  );
    QFile::remove( Store->ProgramInformation.LocalDevelopmentDirectory + "cloc_output.txt" );
    return ( html_result_table );
};
 
 
QString Worker::ParserLddResults( QString ResultFilename )
{
    QString table_string;
    // Read the Ouptut of the ldd Program
    QFile ldd_file( ResultFilename );
    if ( !ldd_file.open( QIODevice::ReadOnly | QIODevice::Text ) )
    {
        LogAdd( LOG_ERROR, MODE_FILE, "Unable to open ldd result file." );
        table_string += "<tr><td>Error occurred reading ldd results.</td></tr>";
    }
    else
    {
        while( !ldd_file.atEnd() )
        {
            QString text_line = ldd_file.readLine();
            table_string += QString( "<tr><td>" + text_line + QString( "</td></tr>" ) );
        }
    }
 
    // Finish table and Return Result
    table_string += QString( "</table>" );
 
    return( table_string );
}
 
QString Worker::FindLibraries(PROJECT_INFORMATION* Store)
{
    QString scratchdir = Store->ProgramInformation.LocalDevelopmentDirectory + "/" + Store->ProjectDesc.ProjectIdent + "/scratch/";
    QString program_file = Store->ProjectDesc.ExeDirectory + "/" + Store->ProjectDesc.ExeName;
 
    QString html_result_table = "<table><tr><th>Dynamic Libraries Linked to Program</th></tr>";
    if ( QSysInfo::kernelType() == "linux" )
    {
        QFile exe_file(program_file);
 
        // Check if the File Exists and is executable
        if (exe_file.exists())
        {
            QFileDevice::Permissions permissions = exe_file.permissions();
            if(permissions & QFileDevice::ExeOwner)
            {
                // Get the Lines Of Code Information
                QProcess ldd;
                ldd.setStandardErrorFile(  scratchdir + "ldd_error.txt",  QIODevice::WriteOnly | QIODevice::Text  );
                ldd.setStandardOutputFile( scratchdir + "ldd_output.txt", QIODevice::WriteOnly | QIODevice::Text  );
                QStringList Arg;
                Arg << program_file;
                ldd.start( "ldd", QStringList() << Arg );
                if (!ldd.waitForStarted(10000))
                {
                    LogAdd( LOG_ERROR, MODE_THREAD, " Process did NOT Start." );
                    html_result_table += "<tr><td>Error - Unable to find dynamically lined libraries.</td></tr>";
                }
                else
                {
                    LogAdd( LOG_DEBUG, MODE_THREAD, QString( "Started  Process " ) );
                }
                if ( !ldd.waitForFinished(100000))
                {
                    LogAdd( LOG_ERROR, MODE_THREAD, " ldd Process did NOT Flag an  End." );
                    html_result_table += "<tr><td>Error occurred while finding Dynamically Linked Libraries.</td></tr>";
                }
                else
                {
                    LogAdd( LOG_DEBUG, MODE_THREAD, " ldd Process finished." );
                    html_result_table += ParserLddResults( scratchdir + "ldd_output.txt" );
                }
 
                // Remove Scratch Files
                QFile::remove( scratchdir + "ldd_error.txt"  );
                QFile::remove( scratchdir + "ldd_output.txt" );
            }
            else
            {
                html_result_table += "<tr><td>File is not currently directly executable.</td></tr>";
            }
        }
        else
        {
            html_result_table += "<tr><td>File does not currently exist.</td></tr>";
        }
    }
    else
    {
        html_result_table += "Currently only Linux Files can be checked for library requirements.</td></tr>";
    }
    html_result_table += "</TABLE>";
 
    return ( html_result_table );
};
 
QString ReadProjectInfo::FindQtBuildVersion(QString ProUserFile)
{
    QString search_string = "ProjectExplorer.ProjectConfiguration.DefaultDisplayName";
    QString target_string;
    QString version_string;
 
    QTextStream in (&ProUserFile);
    QString line;
    do
    {
        line = in.readLine();
        if (!line.contains(search_string, Qt::CaseSensitive))
        {
            target_string = line;
            break;
        }
    }
    while (!line.isNull());
 
    // If possible, Extract the QT Build Version
    if (!target_string.isNull())
    {
        int qt_index = line.indexOf("Qt");
        if (qt_index != -1)
        {
            int version_start = qt_index + 3;
            int space_index = line.indexOf(" ", version_start);
            version_string = line.sliced(version_start, space_index - version_start);
        }
    }
    return(version_string);
}
 
bool Worker::CreateSourceArchive(PROJECT_INFORMATION* ProjectInfo)
{
    bool result = false;
 
    // Check if this should be Invoked
    if (!(ProjectInfo->ProjectDesc.ProjectOptions & CREATE_SOURCE_ARCHIVE))
    {
        return(false);
    }
    else
    {
        QString destination_path = ProjectInfo->ProgramInformation.PrimaryWebsiteDirectory + "/projects/" + ProjectInfo->ProjectDesc.ProjectIdent + "/archive";
        QDir dir;
        if (!dir.mkpath(destination_path))
        {
            LogAdd( LOG_ERROR, MODE_FILE, destination_path + QString( " archive directory NOT created" ) );
        }
        else
        {
            LogAdd( LOG_DEBUG, MODE_FILE, destination_path + QString( " archive directory created" ) );
 
            // Generate the Archive
            QString source_path = ProjectInfo->ProgramInformation.LocalDevelopmentDirectory + "/" + ProjectInfo->ProjectDesc.ProjectIdent + "/source/" + ProjectInfo->ProjectDesc.ExeName + "/";
            dir.cd( source_path );
            QString archive_file = destination_path + "/" + ProjectInfo->ProjectDesc.ExeName + ".tar.gz";
 
            QProcess tar;
            QStringList Arg;
            Arg << "-czf" << archive_file << "--exclude=build" << source_path;
            tar.start( "tar", QStringList() << Arg );
            if (!tar.waitForStarted())
            {
                LogAdd( LOG_ERROR, MODE_THREAD, "tar did NOT Start." );
            }
            else
            {
                LogAdd( LOG_DEBUG, MODE_THREAD, QString( "Started tar Process with " ) + QChar('"' ) + Arg.join( " " )+ QChar('"' ) );
            }
            tar.closeWriteChannel();
            if (!tar.waitForFinished())
            {
                LogAdd( LOG_ERROR, MODE_THREAD, "tar did NOT End." );
            }
            else
            {
                LogAdd( LOG_DEBUG, MODE_THREAD, "tar finished." );
                result = true;
            }
        }
        return(result);
    }
}
 
bool Worker::CreateSourceListFile(const QString Directory, const QString ResultFileName, const QString DevLanguage)
{
    bool result;
 
    QString dev_language = DevLanguage.toUpper();
 
    // Define What Filename To Search For
    QStringList file_filter;
 
    // Set the Filter based on the Language
    if ( dev_language == "ASM" )
    {
        file_filter << "*.asm" << "*.s";
    }
    else if ( dev_language == "BASH" )
    {
        file_filter << "*.sh";
    }
    else if ( dev_language == "BASIC" )
    {
        file_filter << "*.bas" << "*.vb";
    }
    else if ( dev_language == "C++" )
    {
        file_filter << "*.cpp" << "*.c" << "*.cxx" << "*.ino" << "*.h" << "*.hpp";
    }
    else if ( dev_language == "CAD" )
    {
        file_filter << "*.tcw" << "*.tct" << "*.dwg" << "*.stl" << "*.dxf";
    }
    else if ( dev_language == "FORTRAN" )
    {
        file_filter << "*.f" << "*.f90" << "*.f95" << "*.f03";
    }
    else if ( dev_language == "HTML" )
    {
        file_filter << "*.htm" << "*.html" << "*.css" << "*.js" << "*.php";
    }
    else if ( dev_language == "JAVA" )
    {
        file_filter << "*.java" << "*.jar" << "*.ins";
    }
    else if ( dev_language == "JAVASCRIPT" )
    {
        file_filter << "*.js";
    }
    else if ( dev_language == "OCTAVE" )
    {
        file_filter << "*.m";
    }
    else if ( dev_language == "PERL" )
    {
        file_filter << "*.pl" << "*.pm";
    }
    else if ( dev_language == "PHP" )
    {
        file_filter << "*.php" << "*.phtml" << "*.php3" <<  "*.php4" << "*.php5" << "*.php7" << "*.phps";
    }
    else if (dev_language == "LINDENSCRIPT")
    {
      file_filter << "*.lsl" << "*.osl" << "*.conf" << "*.config";
    }
 
    // Set the Directory and What to Look For
    QDir source_directory( Directory );
    source_directory.setFilter( QDir::Files | QDir::NoDotAndDotDot | QDir::Readable );
 
    // Get the List of the Files
    QStringList file_list;
    file_list = source_directory.entryList( file_filter );
 
    // Put the Filename into the Result File
    QFile result_file( ResultFileName );
    if ( !result_file.open( QIODevice::WriteOnly | QIODevice::Text ) )
    {
        result = false;
        LogAdd( LOG_ERROR, MODE_FILE, QString( "Unable to open File List File " ) + ResultFileName );
    }
    else
    {
        LogAdd( LOG_DEBUG, MODE_FILE, QString( "Opened File List File " ) + ResultFileName );
 
        QTextStream out( &result_file );
 
        // Add the Filenames to the File
        for ( const auto& filename : file_list )
        {
            out << filename << "\n";
        }
        result_file.close();
        result = true;
    }
    return( result );
}
 
bool
Worker::CreatePublishList (PROJECT_INFORMATION *ProjectInfo)
{
}
 
QString Worker::CppCheck( PROJECT_INFORMATION* ProjectInfo )
{
    QString result_table;
    QString output_file = ProjectInfo->ProjectDesc.ProjectDirectory + "/scratch/cppcheck_output.txt";
    QString error_file = ProjectInfo->ProjectDesc.ProjectDirectory + "/scratch/cppcheck_error.txt";
    QString file_list  = ProjectInfo->ProjectDesc.ProjectDirectory + "/scratch/file_list.txt";
 
    // Remove any legacy file list so that any file that exists after this routine will be current
    QFile file(file_list);
    if (file.remove())
    {
        LogAdd( LOG_DEBUG, MODE_FILE, QString("Deleted File List: %1").arg(file_list));
    }
    else
    {
        LogAdd( LOG_ERROR, MODE_FILE, QString("Could not delete File List: %1").arg(file_list));
    }
 
    // Set the Directory
    QString directory = ProjectInfo->ProjectDesc.ProjectDirectory + "/source/" + ProjectInfo->ProjectDesc.ExeName;
    QDir::setCurrent(directory);
 
    // Select the Files to Process
    if ( CreateSourceListFile( directory, file_list, ProjectInfo->LangFamilyInfo.ShortName ) )
    {
        // Initialise the cppcheck command line
        QProcess cppcheck;
        cppcheck.setStandardErrorFile(  error_file,  QIODevice::WriteOnly | QIODevice::Text  );
        cppcheck.setStandardOutputFile( output_file, QIODevice::WriteOnly | QIODevice::Text  );
        QStringList arg;
        arg << "--enable=all" << "-UDEBUG" << "--inconclusive" << QString( "--file-list=" ) + file_list;
 
        cppcheck.start( "cppcheck", arg );
        if (!cppcheck.waitForStarted(10000))
        {
            LogAdd( LOG_ERROR, MODE_THREAD, "cppcheck Process did NOT Start." );
            result_table += "ERROR - Unable to scan .cpp code.<BR>";
        }
        else
        {
            LogAdd( LOG_DEBUG, MODE_THREAD, QString( "Started cppcheck Process " ) );
        }
        if (!cppcheck.waitForFinished(100000))
        {
            LogAdd( LOG_ERROR, MODE_THREAD, "ccpcheck Process did NOT End." );
            result_table += "ERROR - cppcheck failed during execution.<BR>";
        }
        else
        {
            LogAdd( LOG_DEBUG, MODE_THREAD, "ccpcheck Process finished." );
 
            // Read the Ouptut of the ccpcheck Program
            QFile ccpcheck_file( error_file );
            if ( !ccpcheck_file.open( QIODevice::ReadOnly | QIODevice::Text ) )
            {
                LogAdd( LOG_ERROR, MODE_FILE, "Unable to open ccpcheck result file." );
                result_table += "ERROR - Unable to read ccpcheck results.<BR>";
            }
            else
            {
                while( !ccpcheck_file.atEnd() )
                {
                    QString line = ccpcheck_file.readLine();
                    line.replace("/*!<", "[").replace("*/", "]");
                    result_table += line  + "<BR>";
                }
 
                // Write to the Website Directory
                QString check_filename = ProjectInfo->ProgramInformation.PrimaryWebsiteDirectory + "/projects/" + ProjectInfo->ProjectDesc.ProjectIdent + "/html/" + CPP_CHECK_FILE;
                QFile cpp_file(check_filename);
                if (cpp_file.open(QIODevice::ReadWrite))
                {
                    QTextStream stream(&cpp_file);
                    stream << result_table << Qt::endl;
 
                     LogAdd( LOG_DEBUG, MODE_THREAD, check_filename + " CCP Check written to Web Directory" );
                }
                else
                {
                    LogAdd( LOG_ERROR, MODE_THREAD, check_filename + " CCP Check NOT written to Web Directory" );
                }
            }
        }
    }
    else
    {
        LogAdd( LOG_ERROR, MODE_FILE, "Unable to list Files for cppcheck." );
    }
    return(result_table);
};
 
 
bool Worker::RecursiveCopy(QString Source, QString Destination)
{
    // Check if the Source is a File or a Directory
    QFileInfo srcFileInfo(Source);
    if (srcFileInfo.isDir())
    {
        // If the Target Directory Doesn't Exist, Create It
        QDir targetDir(Destination);
        if ( !targetDir.exists() )
        {
            // Go Up a Level and Create the Directory
            targetDir.cdUp();
            if (!targetDir.mkpath(QFileInfo(Destination).fileName()))
            {
                return false;
            }
        }
 
        // Copy Each Entry in the Directory to the Target
        QDir sourceDir(Source);
        QStringList fileNames = sourceDir.entryList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot | QDir::Hidden | QDir::System);
        foreach (const QString &fileName, fileNames)
        {
            const QString newSrcFilePath = Source + QLatin1Char('/') + fileName;
            const QString newTgtFilePath = Destination + QLatin1Char('/') + fileName;
            if (!RecursiveCopy(newSrcFilePath, newTgtFilePath))
            {
                return false;
            }
        }
    }
 
    // If it is a File Copy It
    else
    {
        if (!QFile(Source).copy(Destination)) return(false);
    }
    return true;
}
 
bool Worker::CreateInstallScript(PROJECT_INFORMATION* ProjectInfo )
{
    bool result;
 
    // Find the Source Directory
    QString source_directory = ProjectInfo->ProjectDesc.ProjectDirectory + "/autoinstall";
 
    // Set the Destination Directory
    QString destination_directory = ProjectInfo->ProjectDesc.ProjectDirectory + "/scripts";
 
    // Translate the File Recuresively
    result = TranslateRecursively(ProjectInfo, source_directory, destination_directory);
 
    return(result);
}