sicherung der aenderungen

OnDemandUpdatePTU.pro

@@ -41,6 +41,9 @@ DEFINES += QT_DEPRECATED_WARNINGS
 #           up cloning of customer repository.
 # 1.3.13:   Fix: if the customer repository is corrupted, remove it and re-clone
 #           the repository (without checking the ISMAS-trigger (WAIT-)button.
+# 1.3.14:   Add additional check for sanity of customer repository using
+#           "git fsck".
+#           Stream-lined code of update process.
 
 win32 {
     BUILD_DATE=$$system("date /t")

git/git_client.cpp

@@ -279,6 +279,17 @@ std::optional<QStringList> GitClient::gitDiff(QString const &commits) {
     return std::nullopt;
 }
 
+bool GitClient::gitFsck() {
+    bool r = false;
+    if (QDir(m_customerRepository).exists()) {
+        Command c("git fsck");
+        if ((r = c.execute(m_customerRepository)) == false) {
+            QString const &s = c.getCommandResult().trimmed();
+            Utils::printCriticalErrorMsg(QString("GIT FSCK FAILED: %1").arg(s));
+        }
+    }
+    return r;
+}
 /*
  Hat sich nichts geaendert, so werden auch keine Commits <>..<> angezeigt
  */

git/git_client.h

@@ -47,6 +47,8 @@ class GitClient : public QObject {
     std::optional<QStringList> gitDiff(QString const &commit);
     std::optional<QStringList> gitMerge();
 
+    bool gitFsck();
+
     QString gitLastCommit(QString fileName);
     QStringList gitShowReason(QString branchName);
     static QString gitBlob(QString fileName);

ismas/ismas_client.cpp

@@ -390,16 +390,18 @@ QString IsmasClient::errorBackendNotConnected(QString const &info,
                              version.toStdString().c_str());
 }
 
-QString IsmasClient::errorGitClone(int percent, QString const &info, QString const &version) {
+QString IsmasClient::errorGitClone(QString const &info,
+                                   QString const &version) {
     return updateNewsToIsmas("U0003",
-                             percent,
+                             m_progressInPercent,
                              RESULT_CODE::INSTALL_ERROR,
                              "CLONE CUSTOMER REPOSITORY FAILED",
                              info.toStdString().c_str(),
                              version.toStdString().c_str());
 }
 
-QString IsmasClient::backendConnected(QString const &info, QString const &version) {
+QString IsmasClient::backendConnected(QString const &info,
+                                      QString const &version) {
     return updateNewsToIsmas("U0010",
                              m_progressInPercent,
                              RESULT_CODE::SUCCESS,
@@ -408,7 +410,8 @@ QString IsmasClient::backendConnected(QString const &info, QString const &versio
                              version.toStdString().c_str());
 }
 
-QString IsmasClient::execOpkgCommand(QString const &info, QString const &version) {
+QString IsmasClient::execOpkgCommand(QString const &info,
+                                     QString const &version) {
     return updateNewsToIsmas("U0010",
                              m_progressInPercent,
                              RESULT_CODE::SUCCESS,

ismas/ismas_client.h

@@ -177,7 +177,7 @@ public:
     QString cloneAndCheckoutCustomerRepository(QString const &info, QString const &version = QString());   // clone and checkout customer repository
     QString checkoutBranch(QString const &info, QString const &version = QString());   // checkout branch
     QString errorBackendNotConnected(QString const &info, QString const &version = QString());   // checkout branch
-    QString errorGitClone(int percent, QString const &info, QString const &version = QString());
+    QString errorGitClone(QString const &info, QString const &version = QString());
     QString backendConnected(QString const &info, QString const &version = QString());
     QString updateTriggerSet(QString const &info, QString const &version = QString());
     QString errorUpdateTrigger(QString const &info, QString const &version = QString());

mainwindow.cpp

@@ -96,7 +96,7 @@ MainWindow::MainWindow(hwinf *hw, Worker *worker, Update *update, QWidget *paren
     , m_worker(worker)
     , m_width(70)
     , m_progressRunning(false)
-    , m_progressValue(0)
+    // , m_progressValue(0)
     , m_update(update)
     , m_updateStep(UpdateDcEvent::UpdateStep::NONE) {
 
@@ -155,7 +155,9 @@ MainWindow::MainWindow(hwinf *hw, Worker *worker, Update *update, QWidget *paren
     connect(m_worker, SIGNAL(appendText(QString,QString)),this,SLOT(onAppendText(QString,QString)));
     connect(m_worker, SIGNAL(showErrorMessage(QString,QString)),this, SLOT(onShowErrorMessage(QString,QString)));
     connect(m_worker, SIGNAL(showStatusMessage(QString,QString)),this, SLOT(onShowStatusMessage(QString,QString)));
-    connect(m_worker, SIGNAL(replaceLast(QString,QString)),this,SLOT(onReplaceLast(QString,QString)));
+    connect(m_worker, SIGNAL(showErrorMessage(QStringList)),this, SLOT(onShowErrorMessage(QStringList)));
+    connect(m_worker, SIGNAL(showStatusMessage(QString,QString)),this, SLOT(onShowStatusMessage(QString,QString)));
+    connect(m_worker, SIGNAL(replaceLast(QStringList)),this,SLOT(onReplaceLast(QStringList)));
     connect(m_worker, SIGNAL(replaceLast(QStringList,QString)),this, SLOT(onReplaceLast(QStringList,QString)));
 }
 
@@ -178,22 +180,22 @@ void MainWindow::customEvent(QEvent *event) {
             case START_PROGRESS_LOOP: {
                 m_progressRunning = true;
                 ui->updateProgress->reset();
-                m_progressValue = 10;
-                QApplication::postEvent(this, new ProgressEvent(this, m_progressValue));
+                // m_progressValue = 10;
+                QApplication::postEvent(this, new ProgressEvent(this, 1));
             } break;
             case STOP_PROGRESS_LOOP: {
                 m_progressRunning = false;
-                m_progressValue -= 10;
-                m_worker->setProgress(m_progressValue/10);
+                // m_progressValue -= 10;
+                // m_worker->setProgress(m_progressValue/10);
             } break;
             default: {
-                    if (m_progressRunning) {
-                        m_progressValue = progress;
-                        ui->updateProgress->setValue(progress/10);
-                        QApplication::postEvent(this, new ProgressEvent(this, progress+10));
-                        QThread::msleep(500);
-                    }
-                }
+                if (m_progressRunning) {
+                    // m_progressValue = progress;
+                    ui->updateProgress->setValue(progress);
+                    // ueberpruefen: hauptfenster schickt sich selber ein event
+                    // QApplication::postEvent(this, new ProgressEvent(this, progress));
+                    // QThread::msleep(500);
+                }}
             }
         } else
         if (sender == m_worker) {
@@ -448,3 +450,21 @@ void MainWindow::onShowErrorMessage(QString title, QString text) {
 void MainWindow::onShowStatusMessage(QString title, QString text) {
     onShowMessage(title, text);
 }
+
+void MainWindow::onShowErrorMessage(QStringList lst) {
+    if (lst.size() >= 2) {
+        onShowMessage(lst.at(0), lst.at(1));
+    }
+    if (lst.size() == 1) {
+        onShowMessage(lst.at(0), "");
+    }
+}
+
+void MainWindow::onShowStatusMessage(QStringList lst) {
+    if (lst.size() >= 2) {
+        onShowMessage(lst.at(0), lst.at(1));
+    }
+    if (lst.size() == 1) {
+        onShowMessage(lst.at(0), "");
+    }
+}

mainwindow.h

@@ -34,7 +34,7 @@ public:
     static const int BL_IS_UP_COUNT = 5;
     static const int BL_STOP_COUNT = 5;
 
-    int progressValue() const { return m_progressValue; }
+    // int progressValue() const { return m_progressValue; }
     hwinf *getPlugin() { return m_hw; }
     hwinf const *getPlugin() const { return m_hw; }
     Update *getUpdate() { return m_update; }
@@ -48,6 +48,8 @@ public slots:
     void onReplaceLast(QString, QString suffix = "");
     void onShowErrorMessage(QString, QString);
     void onShowStatusMessage(QString, QString);
+    void onShowErrorMessage(QStringList);
+    void onShowStatusMessage(QStringList);
     void onStopStartTimer();
     void onRestartExitTimer();
     void onEnableExit();
@@ -76,7 +78,7 @@ private:
     QTimer *m_startTimer;
     QTimer *m_exitTimer;
     bool m_progressRunning;
-    int m_progressValue;
+    //int m_progressValue;
     Update *m_update;
     UpdateDcEvent::UpdateStep m_updateStep;
 };

update.cpp

@@ -846,8 +846,8 @@ bool Update::doUpdate(int &displayIndex, QStringList const &filesToWorkOn) {
             qCritical() << "UNKNOWN JSON FILE NAME" << fToWorkOn;
             res = false;
         }
-        m_worker->stopProgressLoop();
-        m_worker->setProgress(100);
+        // m_worker->stopProgressLoop();
+        // m_worker->setProgress(100);
 
         if (res == false) {
             break;

utils.cpp

@@ -46,10 +46,12 @@ QString Utils::zoneName(quint8 i) {
     return "N/A";
 }
 
-void Utils::printCriticalErrorMsg(QString const &errorMsg) {
-    qCritical() << QString(80, 'E');
+void Utils::printCriticalErrorMsg(QString const &errorMsg, bool upper, bool lower) {
+    if (upper) qCritical() << QString(80, 'E');
+
     qCritical() << errorMsg;
-    qCritical() << QString(80, 'E');
+
+    if (lower) qCritical() << QString(80, 'E');
 }
 
 void Utils::printCriticalErrorMsg(QStringList const &errorMsg) {
@@ -60,6 +62,14 @@ void Utils::printCriticalErrorMsg(QStringList const &errorMsg) {
     qCritical() << QString(80, 'E');
 }
 
+void Utils::printUpdateStatusMsg(QDebug &debug, QStringList const &updateMsg) {
+    debug << QString(80, 'U');
+    for (int i = 0; i < updateMsg.size(); ++i) {
+        debug << updateMsg.at(i);
+    }
+    debug << QString(80, 'U');
+}
+
 void Utils::printUpdateStatusMsg(QStringList const &updateMsg) {
     qCritical() << QString(80, 'U');
     for (int i = 0; i < updateMsg.size(); ++i) {
@@ -68,16 +78,30 @@ void Utils::printUpdateStatusMsg(QStringList const &updateMsg) {
     qCritical() << QString(80, 'U');
 }
 
-void Utils::printUpdateStatusMsg(QString const &updateMsg) {
-    qCritical() << QString(80, 'U');
+void Utils::printUpdateStatusMsg(QString const &updateMsg, bool upper, bool lower) {
+    if (upper) qCritical() << QString(80, 'U');
+
     qCritical() << updateMsg;
-    qCritical() << QString(80, 'U');
+
+    if (lower) qCritical() << QString(80, 'U');
 }
 
-void Utils::printInfoMsg(QString const &infoMsg) {
-    qCritical() << QString(80, 'I');
+void Utils::printUpdateStatusMsg(QDebug &debug, QString const &updateMsg,
+                                 bool upper, bool lower) {
+    if (upper) debug << QString(80, 'U');
+
+    debug << updateMsg;
+
+    if (lower) debug << QString(80, 'U');
+
+}
+
+void Utils::printInfoMsg(QString const &infoMsg, bool upper, bool lower) {
+    if (upper) qCritical() << QString(80, 'I');
+
     qCritical() << infoMsg;
-    qCritical() << QString(80, 'I');
+
+    if (lower) qCritical() << QString(80, 'I');
 }
 
 void Utils::printInfoMsg(QStringList const &infoMsg) {

utils.h

@@ -8,16 +8,19 @@
 #include <QFileInfo>
 #include <QDateTime>
 #include <QDir>
+#include <QDebug>
 
 namespace Utils {
     int read1stLineOfFile(QString fileName);
     QString zoneName(quint8 i);
-    void printCriticalErrorMsg(QString const &errorMsg);
+    void printCriticalErrorMsg(QString const &errorMsg, bool upper=false, bool lower=false);
     void printCriticalErrorMsg(QStringList const &errorMsg);
-    void printInfoMsg(QString const &infoMsg);
+    void printInfoMsg(QString const &infoMsg, bool upper=false, bool lower=false);
     void printInfoMsg(QStringList const &infoMsg);
+    void printUpdateStatusMsg(QDebug &debug, QStringList const &updateMsg);
     void printUpdateStatusMsg(QStringList const &updateMsg);
-    void printUpdateStatusMsg(QString const &updateMsg);
+    void printUpdateStatusMsg(QString const &updateMsg, bool upper=false, bool lower=false);
+    void printUpdateStatusMsg(QDebug &debug, QString const &updateMsg, bool upper=false, bool lower=false);
     void printLineEditInfo(QStringList const &lines);
     QString getTariffLoadTime(QString fileName);
     QString rstrip(QString const &str);

worker.h

@@ -8,13 +8,17 @@
 #include <QFile>
 #include <QJsonObject>
 #include <QHash>
+#include <QMap>
+#include <QDebug>
 
 #include <optional>
+#include <initializer_list>
 
 #include "worker_thread.h"
 #include "update.h"
 #include "git/git_client.h"
 #include "ismas/ismas_client.h"
+#include "utils.h"
 
 #ifdef PTU5
 #define SERIAL_PORT "ttymxc2"
@@ -22,6 +26,51 @@
 #define SERIAL_PORT "ttyUSB0"
 #endif
 
+#define _STARTED                                (1)
+#define _CHECK_SANITY                           (2)
+#define _CHECK_SANITY_SUCCESS                   (3)
+#define _CHECK_SANITY_FAILURE                   (4)
+#define _REPOSITORY_RECOVERED_SUCCESS           (5)
+#define _REPOSITORY_RECOVERED_FAILURE           (6)
+#define _CHECK_REPOSITORY                       (7)
+#define _CHECK_REPOSITORY_SUCCESS               (8)
+#define _CHECK_REPOSITORY_FAILURE               (9)
+#define _CLONE_REPOSITORY                       (10)
+#define _CLONE_REPOSITORY_SUCCESS               (11)
+#define _CLONE_REPOSITORY_FAILURE               (12)
+#define _CHECKOUT_REPOSITORY                    (13)
+#define _CHECKOUT_REPOSITORY_SUCCESS            (14)
+#define _CHECKOUT_REPOSITORY_FAILURE            (15)
+#define _CHECK_ISMAS_TRIGGER                    (19)
+#define _CHECK_ISMAS_TRIGGER_SUCCESS            (23)
+#define _CHECK_ISMAS_TRIGGER_FAILURE            (24)
+#define _UPDATE_REPOSITORY                      (25)
+#define _UPDATE_REPOSITORY_SUCCESS              (28)
+#define _UPDATE_REPOSITORY_FAILURE              (29)
+#define _CHECK_FOR_REPOSITORY_CHANGES           (30)
+#define _CHECK_FOR_REPOSITORY_CHANGES_SUCCESS   (38)
+#define _CHECK_FOR_REPOSITORY_CHANGES_FAILURE   (39)
+#define _APPLY_REPOSITORY_CHANGES               (40)
+#define _DOWNLOAD_CONFIG_FILE                   (41)
+#define _DOWNLOAD_CONFIG_FILE_SUCCESS           (63)
+#define _DOWNLOAD_CONFIG_FILE_FAILURE           (64)
+#define _DOWNLOAD_DEVICE_CONTROLLER             (65)
+#define _DOWNLOAD_DEVICE_CONTROLLER_SUCCESS     (86)
+#define _DOWNLOAD_DEVICE_CONTROLLER_FAILURE     (87)
+#define _APPLY_REPOSITORY_CHANGES_SUCCESS       (88)
+#define _APPLY_REPOSITORY_CHANGES_FAILURE       (89)
+#define _SYNC_CUSTOMER_REPOSITORY               (90)
+#define _SYNC_CUSTOMER_REPOSITORY_SUCCESS       (91)
+#define _SYNC_CUSTOMER_REPOSITORY_FAILURE       (92)
+#define _SAVE_LOGS                              (94)
+#define _SAVE_LOGS_SUCCESS                      (95)
+#define _SAVE_LOGS_FAILURE                      (96)
+#define _SEND_LAST_VERSION                      (97)
+#define _UPDATE_SUCCEEDED                       (98)
+#define _UPDATE_FAILED                          (99)
+#define _FINISHED                               (100)
+#define _DEBUG                                  (1000)
+#define _ERROR                                  (1001)
 
 enum class UPDATE_STATUS : quint8 {
     NOT_DEFINED,
@@ -65,10 +114,9 @@ struct UpdateStatus {
         : m_updateStatus(s), m_statusDescription(d) {}
 };
 
-QDebug operator<<(QDebug debug, UpdateStatus status);
-QString& operator<<(QString &str, UpdateStatus status);
 
 #define ISMAS_UPDATE_REQUESTS   (10)
+#define CHECK_UPDATE_TRIGGER_SET "Check update trigger ..."
 
 class MainWindow;
 class hwinf;
@@ -109,12 +157,12 @@ class Worker : public QObject {
     UpdateStatus m_updateStatus;
 
     QStringList m_filesToUpdate;
+    QStringList m_filesToDownload;
     bool m_updateProcessRunning;
     int m_displayIndex;
     int m_returnCode;
 
     MainWindow *m_mainWindow;
-    int m_progressValue;
     bool m_withoutIsmasDirectPort;
     QString m_apismVersion;
 
@@ -135,10 +183,98 @@ class Worker : public QObject {
     int sendCloneAndCheckoutSuccess();
     int sendCloneAndCheckoutFailure();
     int sendIsmasTriggerFailure();
+    int sendPullFailure();
+    int sendFileUpdateFailure();
+    int sendRsyncFailure();
+    int sendLastVersionFailure();
+    int sendSaveLogFilesFailure();
+    int sendCustomerEnvironmentConfigurationFailed();
+    int sendFoundFilesToUpdateSuccess();
+    int sendUpdateSucceededAndActivated();
+    int sendFinalResult();
 
+
+    static constexpr const int UPDATE_SUCCESS_AND_ACTIVATED = 0;
     static constexpr const int CLONE_AND_CHECKOUT_SUCCESS = 0;
     static constexpr const int CLONE_AND_CHECKOUT_FAILURE = -3;
     static constexpr const int ISMAS_TRIGGER_FAILURE = -5;
+    static constexpr const int ENVIRONMENT_CONFIG_FAILURE = -6;
+    static constexpr const int GIT_PULL_FAILURE = -7;
+    static constexpr const int UPDATE_FILES_FAILURE = -8;
+    static constexpr const int RSYNC_FAILURE = -9;
+    static constexpr const int SEND_LAST_VERSION_FAILURE = -10;
+    static constexpr const int SAVE_LOG_FILES_FAILURE = -11;
+
+public:
+    enum class UPDATE_STEP {
+        STARTED = _STARTED,
+        CHECK_REPOSITORY = _CHECK_REPOSITORY,
+        CHECK_REPOSITORY_SUCCESS = _CHECK_REPOSITORY_SUCCESS,
+        CHECK_REPOSITORY_FAILURE = _CHECK_REPOSITORY_FAILURE,
+        CHECK_SANITY = _CHECK_SANITY,
+        CHECK_SANITY_SUCCESS = _CHECK_SANITY_SUCCESS,
+        CHECK_SANITY_FAILURE = _CHECK_SANITY_FAILURE,
+        REPOSITORY_RECOVERED_SUCCESS = _REPOSITORY_RECOVERED_SUCCESS,
+        REPOSITORY_RECOVERED_FAILURE = _REPOSITORY_RECOVERED_FAILURE,
+        CLONE_REPOSITORY = _CLONE_REPOSITORY,
+        CLONE_REPOSITORY_SUCCESS = _CLONE_REPOSITORY_SUCCESS,
+        CLONE_REPOSITORY_FAILURE = _CLONE_REPOSITORY_FAILURE,
+        CHECKOUT_REPOSITORY = _CHECKOUT_REPOSITORY,
+        CHECKOUT_REPOSITORY_SUCCESS = _CHECKOUT_REPOSITORY_SUCCESS,
+        CHECKOUT_REPOSITORY_FAILURE = _CHECKOUT_REPOSITORY_FAILURE,
+        CHECK_ISMAS_TRIGGER = _CHECK_ISMAS_TRIGGER,
+        CHECK_ISMAS_TRIGGER_SUCCESS = _CHECK_ISMAS_TRIGGER_SUCCESS,
+        CHECK_ISMAS_TRIGGER_FAILURE = _CHECK_ISMAS_TRIGGER_FAILURE,
+        UPDATE_REPOSITORY = _UPDATE_REPOSITORY,
+        UPDATE_REPOSITORY_SUCCESS = _UPDATE_REPOSITORY_SUCCESS,
+        UPDATE_REPOSITORY_FAILURE = _UPDATE_REPOSITORY_FAILURE,
+        CHECK_FOR_REPOSITORY_CHANGES = _CHECK_FOR_REPOSITORY_CHANGES,
+        CHECK_FOR_REPOSITORY_CHANGES_SUCCESS = _CHECK_FOR_REPOSITORY_CHANGES_SUCCESS,
+        CHECK_FOR_REPOSITORY_CHANGES_FAILURE = _CHECK_FOR_REPOSITORY_CHANGES_FAILURE,
+        APPLY_REPOSITORY_CHANGES = _APPLY_REPOSITORY_CHANGES,
+        DOWNLOAD_CONFIG_FILE = _DOWNLOAD_CONFIG_FILE,
+        DOWNLOAD_CONFIG_FILE_SUCCESS = _DOWNLOAD_CONFIG_FILE_SUCCESS,
+        DOWNLOAD_CONFIG_FILE_FAILURE = _DOWNLOAD_CONFIG_FILE_FAILURE,
+        DOWNLOAD_DEVICE_CONTROLLER = _DOWNLOAD_DEVICE_CONTROLLER,
+        DOWNLOAD_DEVICE_CONTROLLER_SUCCESS = _DOWNLOAD_DEVICE_CONTROLLER_SUCCESS,
+        DOWNLOAD_DEVICE_CONTROLLER_FAILURE = _DOWNLOAD_DEVICE_CONTROLLER_FAILURE,
+        APPLY_REPOSITORY_CHANGES_SUCCESS = _APPLY_REPOSITORY_CHANGES_SUCCESS,
+        APPLY_REPOSITORY_CHANGES_FAILURE = _APPLY_REPOSITORY_CHANGES_FAILURE,
+        SYNC_CUSTOMER_REPOSITORY = _SYNC_CUSTOMER_REPOSITORY,
+        SYNC_CUSTOMER_REPOSITORY_SUCCESS = _SYNC_CUSTOMER_REPOSITORY_SUCCESS,
+        SYNC_CUSTOMER_REPOSITORY_FAILURE = _SYNC_CUSTOMER_REPOSITORY_FAILURE,
+        SAVE_LOGS = _SAVE_LOGS,
+        SAVE_LOGS_SUCCESS = _SAVE_LOGS_SUCCESS,
+        SAVE_LOGS_FAILURE = _SAVE_LOGS_FAILURE,
+        SEND_LAST_VERSION = _SEND_LAST_VERSION,
+        UPDATE_SUCCEEDED = _UPDATE_SUCCEEDED,
+        UPDATE_FAILED = _UPDATE_FAILED,
+        FINISHED = _FINISHED,
+        DEBUG = _DEBUG,
+        ERROR = _ERROR
+    };
+
+private:
+    QStringList m_debugMsg;
+    QStringList m_guiMsg;
+    QStringList m_ismasMsg;
+    UPDATE_STEP m_currentStep;
+    static Worker *instance;
+
+    QDebug CONSOLE(QStringList const &lst = QStringList()) {
+        m_debugMsg = lst;
+        return qDebug();
+    }
+
+    IsmasClient &ISMAS(QStringList const &lst = QStringList()) {
+        m_ismasMsg = lst;
+        return m_ismasClient;
+    }
+
+    Worker *GUI(QStringList const &lst = QStringList()) {
+        m_guiMsg = lst;
+        return this;
+    }
 
 public:
     static QString getATBUpdateToolYoctoVersion();
@@ -165,6 +301,7 @@ public:
     hwinf *getPlugin();
     hwinf const *getPlugin() const;
     void setProgress(int progress);
+    void displayProgressInMainWindow(int progress);
     void startProgressLoop();
     void stopProgressLoop();
 
@@ -183,21 +320,14 @@ public:
     MainWindow *mainWindow() { return m_mainWindow; }
     MainWindow const *mainWindow() const { return m_mainWindow; }
 
-    //friend QDebug operator<<(QDebug debug, Worker const &w) {
-    //    Q_UNUSED(w);
-    //    return debug;
-    //}
-    //friend QString& operator<<(QString &str, Worker const &w) {
-    //    Q_UNUSED(w);
-    //    return str;
-    //}
-
 signals:
     void appendText(QString, QString suffix = "");
     void replaceLast(QString, QString);
     void replaceLast(QStringList, QString);
     void showErrorMessage(QString title, QString description);
     void showStatusMessage(QString title, QString description);
+    void showErrorMessage(QStringList titleAndDesc);
+    void showStatusMessage(QStringList titleAndDesc);
     void stopStartTimer();
     void restartExitTimer();
     void enableExit();
@@ -207,18 +337,464 @@ public slots:
     void update();
 
 private slots:
-    bool updateTriggerSet(int progress);
+    bool updateTriggerSet();
     bool customerEnvironment(int progress);
-    bool filesToUpdate();
-    bool updateFiles(quint8 percent);
-    bool syncCustomerRepositoryAndFS();
-    bool sendIsmasLastVersionNotification();
-    bool saveLogFile();
+    bool filesToUpdate(int progress);
+    bool updateFiles(int percent);
+    bool syncCustomerRepositoryAndFS(int progress);
+    bool sendIsmasLastVersionNotification(int progress);
+    bool saveLogFile(int progress);
 
 private:
     PSAInstalled getPSAInstalled();
     void privateUpdate();
     std::optional<QString> getApismVersion();
+    void printProgress(UPDATE_STEP step);
+
+    static const QMap<UPDATE_STEP, const char*> smap;
+
+    // CONSOLE()
+    friend UPDATE_STEP operator<<(QDebug debug, UPDATE_STEP step) {
+        if (!Worker::instance) {
+            return step;
+        }
+
+        Worker::instance->m_currentStep = step;
+
+        switch (step) {
+        case UPDATE_STEP::STARTED: {
+            Utils::printUpdateStatusMsg(
+                debug,
+                QStringList(smap[step])
+                    << QString("CURRENT TIME ...............%1").arg(QDateTime::currentDateTime().toString(Qt::ISODate))
+                    << QString("OS VERSION .................%1").arg(instance->m_osVersion)
+                    << QString("ATBQT VERSION ..............%1").arg(instance->m_atbqtVersion)
+                    << QString("CPU SERIAL .................%1").arg(instance->m_cpuSerial)
+                    << QString("CUSTOMER_NR ................%1").arg(instance->m_customerNr)
+                    << QString("CUSTOMER_NR_STR ............%1").arg(instance->m_customerNrStr)
+                    << QString("CUSTOMER_REPOSITORY_PATH ...%1").arg(instance->m_customerRepositoryPath)
+                    << QString("CUSTOMER_REPOSITORY ........%1").arg(instance->m_customerRepository)
+                    << QString("MACHINE_NR .................%1").arg(instance->m_machineNr)
+                    << QString("ZONE_NR ....................%1").arg(instance->m_zoneNr)
+                    << QString("BRANCH_NAME ................%1").arg(instance->m_branchName)
+                    << QString("PLUGIN_NAME ................%1").arg(instance->m_pluginName)
+                    << QString("WORKING_DIRECTORY ..........%1").arg(instance->m_workingDirectory)
+                    << QString("APISM VERSION ..............%1").arg(instance->m_apismVersion)
+                    << QString("ATB UPDATE TOOL VERSION ....%1").arg(instance->m_atbUpdateToolVersion));
+        } break;
+        case UPDATE_STEP::CHECK_REPOSITORY:
+        break;
+        case UPDATE_STEP::CHECK_SANITY:
+            Utils::printUpdateStatusMsg(
+                debug,
+                QStringList(smap[step])
+                    << QString("CHECK SANITY OF CUSTOMER REPOSITORY %1")
+                        .arg(instance->m_customerRepository));
+        break;
+        case UPDATE_STEP::CHECK_SANITY_SUCCESS:
+            Utils::printUpdateStatusMsg(
+                debug,
+                QStringList(smap[step])
+                    << QString("SANITY OF CUSTOMER REPOSITORY %1 OK")
+                        .arg(instance->m_customerRepository));
+        break;
+        case UPDATE_STEP::CHECK_SANITY_FAILURE:
+            Utils::printUpdateStatusMsg(
+                debug,
+                QStringList(smap[step])
+                    << QString("CORRUPTED CUSTOMER REPOSITORY %1. REPAIRING...")
+                        .arg(instance->m_customerRepository));
+        break;
+        case UPDATE_STEP::REPOSITORY_RECOVERED_SUCCESS:
+            Utils::printUpdateStatusMsg(
+                debug,
+                QStringList(smap[step])
+                    << QString("CORRUPTED CUSTOMER REPOSITORY %1. REPAIRING DONE")
+                        .arg(instance->m_customerRepository));
+        break;
+        case UPDATE_STEP::REPOSITORY_RECOVERED_FAILURE:
+            Utils::printUpdateStatusMsg(
+                debug,
+                QStringList(smap[step])
+                    << QString("CORRUPTED CUSTOMER REPOSITORY %1. REPAIRING FAILED")
+                        .arg(instance->m_customerRepository));
+        break;
+        case UPDATE_STEP::CHECK_REPOSITORY_SUCCESS:
+        break;
+        case UPDATE_STEP::CHECK_REPOSITORY_FAILURE:
+        break;
+        case UPDATE_STEP::CLONE_REPOSITORY:
+        break;
+        case UPDATE_STEP::CLONE_REPOSITORY_SUCCESS:
+        break;
+        case UPDATE_STEP::CLONE_REPOSITORY_FAILURE:
+        break;
+        case UPDATE_STEP::CHECKOUT_REPOSITORY:
+        break;
+        case UPDATE_STEP::CHECKOUT_REPOSITORY_SUCCESS:
+        break;
+        case UPDATE_STEP::CHECKOUT_REPOSITORY_FAILURE:
+        break;
+        case UPDATE_STEP::CHECK_ISMAS_TRIGGER:
+            Utils::printUpdateStatusMsg(
+                debug,
+                QStringList(smap[step])
+                    << QString("CHECK ISMAS-TRIGGER-STATUS..."));
+        break;
+        case UPDATE_STEP::CHECK_ISMAS_TRIGGER_SUCCESS:
+        break;
+        case UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE:
+        break;
+        case UPDATE_STEP::UPDATE_REPOSITORY:
+        break;
+        case UPDATE_STEP::UPDATE_REPOSITORY_SUCCESS:
+        break;
+        case UPDATE_STEP::UPDATE_REPOSITORY_FAILURE:
+        break;
+        case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES:
+        break;
+        case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES_SUCCESS:
+        break;
+        case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES_FAILURE:
+        break;
+        case UPDATE_STEP::APPLY_REPOSITORY_CHANGES:
+        break;
+        case UPDATE_STEP::DOWNLOAD_CONFIG_FILE:
+        break;
+        case UPDATE_STEP::DOWNLOAD_CONFIG_FILE_SUCCESS:
+        break;
+        case UPDATE_STEP::DOWNLOAD_CONFIG_FILE_FAILURE:
+        break;
+        case UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER:
+        break;
+        case UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER_SUCCESS:
+        break;
+        case UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER_FAILURE:
+        break;
+        case UPDATE_STEP::APPLY_REPOSITORY_CHANGES_SUCCESS:
+        break;
+        case UPDATE_STEP::APPLY_REPOSITORY_CHANGES_FAILURE:
+        break;
+        case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY:
+        break;
+        case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_SUCCESS:
+        break;
+        case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_FAILURE:
+        break;
+        case UPDATE_STEP::SAVE_LOGS:
+        break;
+        case UPDATE_STEP::SAVE_LOGS_SUCCESS:
+        break;
+        case UPDATE_STEP::SAVE_LOGS_FAILURE:
+        break;
+        case UPDATE_STEP::SEND_LAST_VERSION:
+        break;
+        case UPDATE_STEP::UPDATE_SUCCEEDED:
+        break;
+        case UPDATE_STEP::UPDATE_FAILED:
+        break;
+        case UPDATE_STEP::FINISHED:
+        break;
+        case UPDATE_STEP::DEBUG:
+            Utils::printUpdateStatusMsg(
+                debug, QStringList(smap[step]) << instance->m_debugMsg);
+        break;
+        case UPDATE_STEP::ERROR:
+            //Utils::printUpdateStatusMsg(
+            //    debug, QStringList(smap[step]) << instance->m_errorMsg);
+        break;
+        }
+
+        return step;
+    }
+
+    friend UPDATE_STEP operator<<(IsmasClient &ismasClient, UPDATE_STEP step) {
+
+        if (!Worker::instance) {
+            return step;
+        }
+
+        switch (step) {
+        case UPDATE_STEP::STARTED: {
+            ismasClient.setProgressInPercent(_STARTED);
+        } break;
+        case UPDATE_STEP::CHECK_REPOSITORY:
+            ismasClient.setProgressInPercent(_CHECK_REPOSITORY);
+        break;
+        case UPDATE_STEP::CHECK_REPOSITORY_SUCCESS:
+        break;
+        case UPDATE_STEP::CHECK_REPOSITORY_FAILURE:
+        break;
+        case UPDATE_STEP::CHECK_SANITY:
+            ismasClient.setProgressInPercent(_CHECK_SANITY);
+        break;
+        case UPDATE_STEP::CHECK_SANITY_SUCCESS:
+            ismasClient.setProgressInPercent(_CHECK_SANITY_SUCCESS);
+        break;
+        case UPDATE_STEP::CHECK_SANITY_FAILURE:
+            ismasClient.setProgressInPercent(_CHECK_SANITY_FAILURE);
+        break;
+        case UPDATE_STEP::REPOSITORY_RECOVERED_SUCCESS:
+        break;
+        case UPDATE_STEP::REPOSITORY_RECOVERED_FAILURE:
+        break;
+        case UPDATE_STEP::CLONE_REPOSITORY:
+            ismasClient.setProgressInPercent(_CLONE_REPOSITORY);
+        break;
+        case UPDATE_STEP::CLONE_REPOSITORY_SUCCESS: {
+            ismasClient.setProgressInPercent(_CLONE_REPOSITORY_SUCCESS);
+            QString const &ismasUpdateNews =
+                QString("#M=APISM#C=CMD_EVENT#J=") +
+                    ismasClient.updateNewsToIsmas(
+                        "U0010",
+                        _CLONE_REPOSITORY_SUCCESS,
+                        IsmasClient::RESULT_CODE::SUCCESS,
+                        smap[step],
+                        QString("CLONED REPOSITORY %1 AND CHECKED OUT BRANCH %2")
+                            .arg(instance->m_customerRepository)
+                            .arg(instance->m_gc.branchName()).toStdString().c_str(),
+                        "");
+            ismasClient.sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
+                                                   ismasUpdateNews);
+        } break;
+        case UPDATE_STEP::CLONE_REPOSITORY_FAILURE: {
+            ismasClient.setProgressInPercent(_CLONE_REPOSITORY_FAILURE);
+            QString const &ismasUpdateNews =
+                QString("#M=APISM#C=CMD_EVENT#J=") +
+                    ismasClient.updateNewsToIsmas(
+                        "U0003",
+                        _CLONE_REPOSITORY_FAILURE,
+                        IsmasClient::RESULT_CODE::INSTALL_ERROR,
+                        smap[step],
+                        QString("CLONING REPOSITORY %1 OR CHECKING OUT BRANCH %2 FAILED")
+                            .arg(instance->m_customerRepository)
+                            .arg(instance->m_gc.branchName()).toStdString().c_str(),
+                        "");
+            ismasClient.sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
+                                                   ismasUpdateNews);
+        } break;
+        case UPDATE_STEP::CHECKOUT_REPOSITORY:
+            ismasClient.setProgressInPercent(_CHECKOUT_REPOSITORY);
+        break;
+        case UPDATE_STEP::CHECKOUT_REPOSITORY_SUCCESS:
+            ismasClient.setProgressInPercent(_CHECKOUT_REPOSITORY_SUCCESS);
+            ismasClient.sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
+                QString("#M=APISM#C=CMD_EVENT#J=") +
+                    ismasClient.cloneAndCheckoutCustomerRepository(
+                          QString("CHECKED OUT REPOSITORY %1 AND CHECKED OUT BRANCH %2")
+                            .arg(instance->m_customerRepository)
+                            .arg(instance->m_gc.branchName())));
+        break;
+        case UPDATE_STEP::CHECKOUT_REPOSITORY_FAILURE:
+            ismasClient.setProgressInPercent(_CHECKOUT_REPOSITORY_FAILURE);
+        break;
+        break;
+        case UPDATE_STEP::CHECK_ISMAS_TRIGGER:
+            ismasClient.setProgressInPercent(_CHECK_ISMAS_TRIGGER);
+        break;
+        case UPDATE_STEP::CHECK_ISMAS_TRIGGER_SUCCESS:
+            ismasClient.setProgressInPercent(_CHECK_ISMAS_TRIGGER_SUCCESS);
+            ismasClient.sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
+                QString("#M=APISM#C=CMD_EVENT#J=") +
+                         ismasClient.updateTriggerSet("ISMAS TRIGGER SET", ""));
+        break;
+        case UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE:
+            ismasClient.setProgressInPercent(_CHECK_ISMAS_TRIGGER_FAILURE);
+            ismasClient.sendRequestReceiveResponse(IsmasClient::APISM::DB_PORT,
+                QString("#M=APISM#C=CMD_EVENT#J=") +
+                    ismasClient.errorUpdateTrigger(instance->m_ismasMsg.join(' '), ""));
+        break;
+        case UPDATE_STEP::UPDATE_REPOSITORY:
+            ismasClient.setProgressInPercent(_UPDATE_REPOSITORY);
+        break;
+        case UPDATE_STEP::UPDATE_REPOSITORY_SUCCESS:
+            ismasClient.setProgressInPercent(_UPDATE_REPOSITORY_SUCCESS);
+        break;
+        case UPDATE_STEP::UPDATE_REPOSITORY_FAILURE:
+            ismasClient.setProgressInPercent(_UPDATE_REPOSITORY_FAILURE);
+        break;
+        case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES:
+            ismasClient.setProgressInPercent(_CHECK_FOR_REPOSITORY_CHANGES);
+        break;
+        case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES_SUCCESS:
+            ismasClient.setProgressInPercent(_CHECK_FOR_REPOSITORY_CHANGES_SUCCESS);
+        break;
+        case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES_FAILURE:
+            ismasClient.setProgressInPercent(_CHECK_FOR_REPOSITORY_CHANGES_FAILURE);
+        break;
+        case UPDATE_STEP::APPLY_REPOSITORY_CHANGES:
+            ismasClient.setProgressInPercent(_APPLY_REPOSITORY_CHANGES);
+        break;
+        case UPDATE_STEP::DOWNLOAD_CONFIG_FILE:
+            ismasClient.setProgressInPercent(_DOWNLOAD_CONFIG_FILE);
+        break;
+        case UPDATE_STEP::DOWNLOAD_CONFIG_FILE_SUCCESS:
+            ismasClient.setProgressInPercent(_DOWNLOAD_CONFIG_FILE_SUCCESS);
+        break;
+        case UPDATE_STEP::DOWNLOAD_CONFIG_FILE_FAILURE:
+            ismasClient.setProgressInPercent(_DOWNLOAD_CONFIG_FILE_FAILURE);
+        break;
+        case UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER:
+            ismasClient.setProgressInPercent(_DOWNLOAD_DEVICE_CONTROLLER);
+        break;
+        case UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER_SUCCESS:
+            ismasClient.setProgressInPercent(_DOWNLOAD_DEVICE_CONTROLLER_SUCCESS);
+        break;
+        case UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER_FAILURE:
+            ismasClient.setProgressInPercent(_DOWNLOAD_DEVICE_CONTROLLER_FAILURE);
+        break;
+        case UPDATE_STEP::APPLY_REPOSITORY_CHANGES_SUCCESS:
+            ismasClient.setProgressInPercent(_APPLY_REPOSITORY_CHANGES_SUCCESS);
+        break;
+        case UPDATE_STEP::APPLY_REPOSITORY_CHANGES_FAILURE:
+            ismasClient.setProgressInPercent(_APPLY_REPOSITORY_CHANGES_FAILURE);
+        break;
+        case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY:
+            ismasClient.setProgressInPercent(_SYNC_CUSTOMER_REPOSITORY);
+        break;
+        case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_SUCCESS:
+            ismasClient.setProgressInPercent(_SYNC_CUSTOMER_REPOSITORY_SUCCESS);
+        break;
+        case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_FAILURE:
+            ismasClient.setProgressInPercent(_SYNC_CUSTOMER_REPOSITORY_FAILURE);
+        break;
+        case UPDATE_STEP::SAVE_LOGS:
+            ismasClient.setProgressInPercent(_SAVE_LOGS);
+        break;
+        case UPDATE_STEP::SAVE_LOGS_SUCCESS:
+            ismasClient.setProgressInPercent(_SAVE_LOGS_SUCCESS);
+        break;
+        case UPDATE_STEP::SAVE_LOGS_FAILURE:
+            ismasClient.setProgressInPercent(_SAVE_LOGS_FAILURE);
+        break;
+        case UPDATE_STEP::SEND_LAST_VERSION:
+            ismasClient.setProgressInPercent(_SEND_LAST_VERSION);
+        break;
+        case UPDATE_STEP::UPDATE_SUCCEEDED:
+            ismasClient.setProgressInPercent(_UPDATE_SUCCEEDED);
+        break;
+        case UPDATE_STEP::UPDATE_FAILED:
+            ismasClient.setProgressInPercent(_UPDATE_FAILED);
+        break;
+        case UPDATE_STEP::FINISHED:
+            ismasClient.setProgressInPercent(_FINISHED);
+        break;
+        case UPDATE_STEP::DEBUG:
+        break;
+        case UPDATE_STEP::ERROR:
+        break;
+        }
+
+        return step;
+    }
+
+    friend UPDATE_STEP operator<<(Worker *worker, UPDATE_STEP step) {
+        switch (step) {
+        case UPDATE_STEP::STARTED:
+        break;
+        case UPDATE_STEP::CHECK_REPOSITORY:
+            emit worker->appendText("\nInitializing customer environment ...");
+        break;
+        case UPDATE_STEP::CHECK_SANITY:
+        break;
+        case UPDATE_STEP::CHECK_SANITY_SUCCESS:
+        break;
+        case UPDATE_STEP::CHECK_SANITY_FAILURE:
+        break;
+        case UPDATE_STEP::REPOSITORY_RECOVERED_SUCCESS:
+        break;
+        case UPDATE_STEP::REPOSITORY_RECOVERED_FAILURE:
+        break;
+        case UPDATE_STEP::CHECK_REPOSITORY_SUCCESS:
+        break;
+        case UPDATE_STEP::CHECK_REPOSITORY_FAILURE:
+        break;
+        case UPDATE_STEP::CLONE_REPOSITORY:
+            emit worker->appendText("\nInitializing customer environment ...");
+        break;
+        case UPDATE_STEP::CLONE_REPOSITORY_SUCCESS:
+            emit worker->replaceLast("Initializing customer environment",
+                                     Worker::UPDATE_STEP_DONE);
+        break;
+        case UPDATE_STEP::CLONE_REPOSITORY_FAILURE:
+            emit worker->replaceLast("Initializing customer environment",
+                                     Worker::UPDATE_STEP_FAIL);
+        break;
+        case UPDATE_STEP::CHECKOUT_REPOSITORY:
+        break;
+        case UPDATE_STEP::CHECKOUT_REPOSITORY_SUCCESS:
+        break;
+        case UPDATE_STEP::CHECKOUT_REPOSITORY_FAILURE:
+        break;
+        case UPDATE_STEP::CHECK_ISMAS_TRIGGER:
+            emit worker->appendText("\n" CHECK_UPDATE_TRIGGER_SET);
+        break;
+        case UPDATE_STEP::CHECK_ISMAS_TRIGGER_SUCCESS:
+        break;
+        case UPDATE_STEP::CHECK_ISMAS_TRIGGER_FAILURE:
+            emit worker->showErrorMessage(worker->m_guiMsg);
+            emit worker->replaceLast(CHECK_UPDATE_TRIGGER_SET, UPDATE_STEP_FAIL);
+        break;
+        case UPDATE_STEP::UPDATE_REPOSITORY:
+        break;
+        case UPDATE_STEP::UPDATE_REPOSITORY_SUCCESS:
+        break;
+        case UPDATE_STEP::UPDATE_REPOSITORY_FAILURE:
+        break;
+        case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES:
+        break;
+        case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES_SUCCESS:
+        break;
+        case UPDATE_STEP::CHECK_FOR_REPOSITORY_CHANGES_FAILURE:
+        break;
+        case UPDATE_STEP::APPLY_REPOSITORY_CHANGES:
+        break;
+        case UPDATE_STEP::DOWNLOAD_CONFIG_FILE:
+        break;
+        case UPDATE_STEP::DOWNLOAD_CONFIG_FILE_SUCCESS:
+        break;
+        case UPDATE_STEP::DOWNLOAD_CONFIG_FILE_FAILURE:
+        break;
+        case UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER:
+        break;
+        case UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER_SUCCESS:
+        break;
+        case UPDATE_STEP::DOWNLOAD_DEVICE_CONTROLLER_FAILURE:
+        break;
+        case UPDATE_STEP::APPLY_REPOSITORY_CHANGES_SUCCESS:
+        break;
+        case UPDATE_STEP::APPLY_REPOSITORY_CHANGES_FAILURE:
+        break;
+        case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY:
+        break;
+        case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_SUCCESS:
+        break;
+        case UPDATE_STEP::SYNC_CUSTOMER_REPOSITORY_FAILURE:
+        break;
+        case UPDATE_STEP::SAVE_LOGS:
+        break;
+        case UPDATE_STEP::SAVE_LOGS_SUCCESS:
+        break;
+        case UPDATE_STEP::SAVE_LOGS_FAILURE:
+        break;
+        case UPDATE_STEP::SEND_LAST_VERSION:
+        break;
+        case UPDATE_STEP::UPDATE_SUCCEEDED:
+        break;
+        case UPDATE_STEP::UPDATE_FAILED:
+        break;
+        case UPDATE_STEP::FINISHED:
+        break;
+        case UPDATE_STEP::DEBUG:
+            emit worker->showStatusMessage(worker->m_guiMsg);
+        break;
+        case UPDATE_STEP::ERROR:
+            emit worker->showErrorMessage(worker->m_guiMsg);
+        break;
+        }
+
+        return step;
+    }
 };
 
 #endif // WORKER_H_INCLUDED