logwidget 추가

git-svn-id: svn://192.168.0.12/source@301 8346c931-da38-4b9b-9d4c-e48b93cbd075

EffectUI/EffectUI.pro

@@ -22,7 +22,11 @@ SOURCES += main.cpp\
     stimer.cpp \
     sadddelwidget.cpp \
     srunprocess.cpp \
-    sparentprocess.cpp
+    sparentprocess.cpp \
+    scompanyprocess.cpp \
+    serrorprocess.cpp \
+    srunningprocess.cpp \
+    slogwidget.cpp
 
 HEADERS  += widget.h \
     scompanylistwidget.h \
@@ -32,6 +36,10 @@ HEADERS  += widget.h \
     stimer.h \
     sadddelwidget.h \
     srunprocess.h \
-    sparentprocess.h
+    sparentprocess.h \
+    scompanyprocess.h \
+    serrorprocess.h \
+    srunningprocess.h \
+    slogwidget.h
 
 FORMS    += widget.ui

EffectUI/EffectUI.pro.user

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE QtCreatorProject>
-<!-- Written by QtCreator 3.3.0, 2016-10-17T19:05:38. -->
+<!-- Written by QtCreator 3.3.0, 2016-10-19T19:14:14. -->
 <qtcreator>
  <data>
   <variable>EnvironmentId</variable>

EffectUI/scompanyprocess.cpp

@@ -0,0 +1,220 @@
+#include "scompanyprocess.h"
+#include "sutilfunction.h"
+#include <QSqlDatabase>
+#include <QSqlQuery>
+#include <QSqlError>
+#include <QString>
+#include <QDate>
+#include <QStringList>
+
+
+namespace
+{
+const QString strDatabaseName("processlist");
+}
+
+
+SCompanyProcess::SCompanyProcess():SParentProcess(),
+    m_iterEffectRow(nullptr), m_iterRunOrderList(nullptr), m_bDoneCompany(false)
+{
+    databaseSetting(strDatabaseName);
+    QObject::connect(this, &SCompanyProcess::signalTerminateEachEvent,
+                     this, &SCompanyProcess::slotTerminateEachEvent);
+}
+
+void SCompanyProcess::setList(const QVector<int>& _list)
+{
+    m_vecRunList = _list;
+}
+
+void SCompanyProcess::setList(QVector<int>&& _list)
+{
+    m_vecRunList = std::move(_list);
+}
+
+void SCompanyProcess::setList(const QVector<SEffectRow>& _list)
+{
+
+}
+
+void SCompanyProcess::setList(QVector<SEffectRow>&& _list)
+{
+
+}
+
+void SCompanyProcess::runInit()
+{
+    setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_INIT);
+    QSqlDatabase db = QSqlDatabase::database(strDatabaseName);
+    if (!db.open())
+    {
+        setError(SError(E_ERROR_CODE::DB_OPEN_ERROR, db.lastError().text()));
+        emit signalTerminateError(getError());
+        return;
+    }
+
+    QString strQuery("select num, enddate from company where enddate in (");
+    foreach (auto& num, m_vecRunList)
+    {
+        strQuery += (QString::number(num) + ",");
+    }
+    strQuery = strQuery.left(strQuery.length() - 1);
+    strQuery += ")";
+
+    QSqlQuery query(db);
+    if (!query.exec(strQuery))
+    {
+        setError(SError(E_ERROR_CODE::DB_QUERY_ERROR, query.lastQuery() + "\n" + query.lastError().text()));
+        emit signalTerminateError(getError());
+        return;
+    }
+
+    while (query.next())
+    {
+        QDate enddate = QDate::fromString(query.value(1).toString(), "yyyy-MM-dd");
+        QDate today = QDate::currentDate();
+
+        if (today <= enddate.addMonths(1))
+        {
+            m_vecRunOrderList.push_back(query.value(0).toInt());
+        }
+    }
+
+    strQuery = "select company.num, name, startdate, enddate, t.event_num, "
+               "t.date, t.url, t.eventcode, t.platformname_num from company "
+               "join (select company_num, event_num, event.date, event.url, event.eventcode, "
+               "event.platformname_num from company_event_map join event on company_event_map.event_num = event.num) "
+               "as t on company.num = t.company_num where company.num in (";
+
+    foreach (auto &num, m_vecRunOrderList)
+    {
+        strQuery += (QString::number(num) + ",");
+    }
+
+    strQuery = strQuery.left(strQuery.length() - 1);
+    strQuery += ")";
+    if (!query.exec(strQuery))
+    {
+        setError(SError(E_ERROR_CODE::DB_QUERY_ERROR, query.lastQuery() + "\n" + query.lastError().text()));
+        emit signalTerminateError(getError());
+        return;
+    }
+/*
+    foreach (auto &num, m_vecRunOrderList)
+    {
+        m_vecRunOrderList.insert(num, QVector<SEffectRow>());
+    }
+*/
+    while (query.next())
+    {
+
+        if (!m_mapEffectRow.contains(query.value(0).toInt()))
+            m_mapEffectRow.insert(query.value(0).toInt(), QVector<SEffectRow>());
+
+        SEffectRow row(query.value(0).toInt(),
+                       query.value(1).toString().trimmed(),
+                       QDate::fromString(query.value(2).toString().trimmed(), "yyyy-MM-dd"),
+                       QDate::fromString(query.value(3).toString().trimmed(), "yyyy-MM-dd"),
+                       query.value(4).toInt(),
+                       QDate::fromString(query.value(5).toString().trimmed(), "yyyy-MM-dd"),
+                       query.value(6).toString().trimmed(),
+                       query.value(7).toString().trimmed(),
+                       query.value(8).toInt()
+                       );
+
+        m_mapEffectRow[query.value(0).toInt()].append(row);
+    }
+
+    initIterator();
+
+    setInnerMode(E_INNER_RUN_MODE::MODE_RUN_EVENTCODE);
+    db.close();
+}
+
+void SCompanyProcess::initIterator()
+{
+    m_iterRunOrderList = m_vecRunList.begin();
+
+    while (m_iterRunOrderList != m_vecRunList.end())
+    {
+        if (m_mapEffectRow.contains(*m_iterRunOrderList))
+        {
+            m_iterEffectRow = m_mapEffectRow[*m_iterRunOrderList].begin();
+            break;
+        }
+        else
+        {
+            ++m_iterRunOrderList;
+        }
+    }
+}
+
+void SCompanyProcess::nextIterator()
+{
+    ++m_iterEffectRow;
+    if (m_iterEffectRow == m_mapEffectRow[*m_iterRunOrderList].end())
+    {
+        m_bDoneCompany = true;
+        while (m_iterRunOrderList != m_vecRunList.end())
+        {
+            if (m_mapEffectRow.contains(*m_iterRunOrderList))
+            {
+                m_iterEffectRow = m_mapEffectRow[*m_iterRunOrderList].begin();
+                break;
+            }
+            else
+            {
+                ++m_iterRunOrderList;
+            }
+        }
+    }
+    else
+        m_bDoneCompany = false;
+}
+
+bool SCompanyProcess::isDone()
+{
+    return m_iterRunOrderList == m_vecRunList.end();
+}
+
+void SCompanyProcess::runEventCode()
+{
+    setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_EVENTCODE);
+    if (isUserAbort())
+    {
+        setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_TERMINATE);
+        emit signalUserAbort();
+        return;
+    }
+
+    if (isDone())
+    {
+        setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_TERMINATE);
+        emit signalTerminateNormal();
+        return;
+    }
+
+    SEffectRow row = *m_iterEffectRow;
+    setCurrentEffectRow(row);
+    nextIterator();
+
+    runProcess(getProcessArguments(row));
+}
+
+void SCompanyProcess::clear()
+{
+    SParentProcess::clear();
+    m_vecRunList.clear();
+    m_vecRunOrderList.clear();
+    m_mapEffectRow.clear();
+    m_bDoneCompany = false;
+    m_iterEffectRow = nullptr;
+    m_iterRunOrderList = nullptr;
+}
+
+void SCompanyProcess::slotTerminateEachEvent(int _num, E_CRAWL_STATE _state)
+{
+    if (m_bDoneCompany)
+        emit signalTerminateCompany(_num);
+}
+

EffectUI/scompanyprocess.h

@@ -0,0 +1,40 @@
+#ifndef SCOMPANYPROCESS
+#define SCOMPANYPROCESS
+#include "sparentprocess.h"
+
+class SCompanyProcess:public SParentProcess
+{
+    Q_OBJECT
+
+public:
+    SCompanyProcess();
+    virtual void setList(const QVector<int>& _list) override;
+    virtual void setList(QVector<int>&& _list) override;
+    virtual void setList(const QVector<SEffectRow>& _list) override;
+    virtual void setList(QVector<SEffectRow>&& _list) override;
+    virtual void runInit() override;
+    virtual void runEventCode() override;
+    virtual void clear() override;
+
+signals:
+    void signalTerminateCompany(int _company_num);
+
+private:
+    void initIterator();
+    void nextIterator();
+    bool isDone();
+
+private slots:
+    void slotTerminateEachEvent(int _num, E_CRAWL_STATE _state);
+
+private:
+    QVector<int> m_vecRunList;
+    QVector<int> m_vecRunOrderList;
+    QMap<int, QVector<SEffectRow>> m_mapEffectRow;
+    QVector<int>::iterator m_iterRunOrderList;
+    QVector<SEffectRow>::iterator m_iterEffectRow;
+    bool m_bDoneCompany;
+};
+
+#endif // SCOMPANYPROCESS
+

EffectUI/serrorprocess.cpp

@@ -0,0 +1,90 @@
+#include "serrorprocess.h"
+
+SErrorProcess::SErrorProcess():SParentProcess(), m_iterEffectRow(nullptr)
+{
+    QObject::connect(this, &SErrorProcess::signalTerminateEachEvent,
+                     this, &SErrorProcess::slotTerminateEachEvent);
+}
+
+
+void SErrorProcess::setList(const QVector<int>& _list)
+{
+
+}
+
+void SErrorProcess::setList(QVector<int>&& _list)
+{
+
+}
+
+void SErrorProcess::setList(const QVector<SEffectRow>& _list)
+{
+    m_vecRunList = _list;
+}
+
+void SErrorProcess::setList(QVector<SEffectRow>&& _list)
+{
+    m_vecRunList = std::move(_list);
+}
+
+void SErrorProcess::runInit()
+{
+    initIterator();
+}
+
+void SErrorProcess::runEventCode()
+{
+    setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_EVENTCODE);
+    if (isUserAbort())
+    {
+        setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_TERMINATE);
+        emit signalUserAbort();
+        return;
+    }
+
+    if (isDone())
+    {
+        setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_TERMINATE);
+        emit signalTerminateNormal();
+        return;
+    }
+
+    SEffectRow row = *m_iterEffectRow;
+    setCurrentEffectRow(row);
+    nextIterator();
+
+    runProcess(getProcessArguments(row));
+}
+
+void SErrorProcess::clear()
+{
+    SParentProcess::clear();
+    m_vecRunList.clear();
+    m_iterEffectRow = nullptr;
+}
+
+void SErrorProcess::slotTerminateEachEvent(int _num, E_CRAWL_STATE _state)
+{
+    if (_state == E_CRAWL_STATE::OK)
+    {
+        emit signalTerminateCompany(_num);
+    }
+}
+
+void SErrorProcess::initIterator()
+{
+    m_iterEffectRow = m_vecRunList.begin();
+}
+
+void SErrorProcess::nextIterator()
+{
+    ++m_iterEffectRow;
+}
+
+bool SErrorProcess::isDone()
+{
+    return m_iterEffectRow == m_vecRunList.end();
+}
+
+
+

EffectUI/serrorprocess.h

@@ -0,0 +1,38 @@
+#ifndef SERRORPROCESS
+#define SERRORPROCESS
+
+#include "sparentprocess.h"
+
+class SErrorProcess:public SParentProcess
+{
+    Q_OBJECT
+
+public:
+    SErrorProcess();
+    virtual void setList(const QVector<int>& _list) override;
+    virtual void setList(QVector<int>&& _list) override;
+    virtual void setList(const QVector<SEffectRow>& _list) override;
+    virtual void setList(QVector<SEffectRow>&& _list) override;
+    virtual void runInit() override;
+    virtual void runEventCode() override;
+    virtual void clear() override;
+
+signals:
+    void signalTerminateCompany(int _company_num);
+
+private:
+    void initIterator();
+    void nextIterator();
+    bool isDone();
+
+private slots:
+    void slotTerminateEachEvent(int _num, E_CRAWL_STATE _state);
+
+private:
+    QVector<SEffectRow> m_vecRunList;
+    QVector<SEffectRow>::iterator m_iterEffectRow;
+};
+
+
+#endif // SERRORPROCESS
+

EffectUI/slogwidget.cpp

@@ -0,0 +1,53 @@
+#include "slogwidget.h"
+#include <QCoreApplication>
+#include <QString>
+#include <QListWidget>
+#include <QFile>
+#include <QTextStream>
+#include <QTime>
+#include <QVBoxLayout>
+
+SLogWidget::SLogWidget(QWidget *parent):QWidget(parent),
+    m_plwLog(new QListWidget(this)), m_pLayout(new QVBoxLayout(this))
+{
+    m_pLayout->addWidget(m_plwLog);
+    setLayout(m_pLayout);
+}
+
+
+void SLogWidget::writeLog(const QString& _strLog)
+{
+    QTime time = QTime::currentTime();
+    QString strOut = time.toString("[hh:mm:ss] ") + _strLog;
+    if(strOut.length() <= 1024)
+        m_plwLog->addItem(strOut);
+    else
+        m_plwLog->addItem(strOut.left(1024));
+    QDate date = QDate::currentDate();
+
+    QFile file(date.toString(Qt::ISODate)+ "_" + QString::number(QCoreApplication::applicationPid())+ ".log");
+    if (!file.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Append))
+        return;
+
+    QTextStream out(&file);
+    out << strOut << "\n";
+    file.close();
+
+    if (m_plwLog->count() > 512)
+    {
+        m_plwLog->removeItemWidget(m_plwLog->item(0));
+        QListWidgetItem* item = m_plwLog->takeItem(0);
+        delete item;
+    }
+    m_plwLog->setCurrentRow( m_plwLog->count() - 1 );
+    m_plwLog->repaint();
+}
+
+
+void SLogWidget::slotWriteLog(const QString& _strLog)
+{
+    writeLog(_strLog);
+}
+
+
+

EffectUI/slogwidget.h

@@ -0,0 +1,27 @@
+#ifndef SLOGWIDGET
+#define SLOGWIDGET
+
+#include <QWidget>
+
+class QListWidget;
+class QString;
+class QVBoxLayout;
+
+class SLogWidget: public QWidget
+{
+    Q_OBJECT
+public:
+    SLogWidget(QWidget* parent = nullptr);
+    void writeLog(const QString& _strLog);
+
+public slots:
+    void slotWriteLog(const QString& _strLog);
+
+private:
+    QListWidget* m_plwLog;
+    QVBoxLayout* m_pLayout;
+};
+
+
+#endif // SLOGWIDGET
+

EffectUI/sparentprocess.cpp

@@ -11,23 +11,14 @@ const int TIMEOUT = 180; // 3 minutes
 const QString SPLIT_KEYWORD = "!@#";
 }
 
-enum class SParentProcess::E_INNER_RUN_MODE:unsigned short
-{
-    MODE_WAIT = 0,
-    MODE_RUN_INIT,
-    MODE_RUN_EVENTCODE,
-    MODE_WAIT_INIT,
-    MODE_WAIT_EVENTCODE,
-    MODE_WAIT_TERMINATE,
-    MODE_WAIT_HANGING,
-    MODE_FINISH = MODE_WAIT
-};
 
 SParentProcess::SParentProcess():m_pProcess(new QProcess(this)), m_bRunning(false), nTime(0),
     m_bUserAbort(false), m_eInnerMode(E_INNER_RUN_MODE::MODE_WAIT)
 {
     QObject::connect(m_pProcess, SIGNAL(QProcess::finished(int, QProcess::ExitStatus)),
                      this, SLOT(SParentProcess::finishedProcess(int, QProcess::ExitStatus)));
+    QObject::connect(this, &SParentProcess::signalTerminateError,
+                     this, &SParentProcess::slotTerminateError);
 }
 
 void SParentProcess::clear()
@@ -36,6 +27,9 @@ void SParentProcess::clear()
     m_mapReportSummary.clear();
     m_erCurrentRow = SEffectRow();
     m_error = SError();
+    m_bUserAbort = false;
+    nTime = 0;
+    m_bRunning = false;
 }
 
 void SParentProcess::setInnerMode(E_INNER_RUN_MODE _mode)
@@ -43,7 +37,7 @@ void SParentProcess::setInnerMode(E_INNER_RUN_MODE _mode)
     m_eInnerMode = _mode;
 }
 
-QVector<SError> SParentProcess::getErrorList() const
+QVector<SEffectRow> SParentProcess::getErrorList() const
 {
     return m_vecError;
 }
@@ -84,9 +78,14 @@ QStringList SParentProcess::getProcessArguments(SEffectRow&& _row) const
     return QStringList();
 }
 
-void SParentProcess::runProcess()
-{
 
+
+void SParentProcess::runProcess(QStringList _arguments)
+{
+    QString arg = _arguments.at(0);
+    _arguments.removeFirst();
+
+    m_pProcess->start(arg, _arguments);
 }
 
 void SParentProcess::setError(const SError& _error)
@@ -111,6 +110,7 @@ void SParentProcess::update()
 
     case E_INNER_RUN_MODE::MODE_WAIT:
     {
+        clear();
         setInnerMode(E_INNER_RUN_MODE::MODE_RUN_INIT);
         break;
     }
@@ -123,6 +123,7 @@ void SParentProcess::update()
 
     case E_INNER_RUN_MODE::MODE_RUN_EVENTCODE:
     {
+        nTime = 0;
         runEventCode();
         break;
     }
@@ -131,8 +132,8 @@ void SParentProcess::update()
     {
         if (++nTime >= TIMEOUT)
         {
-            m_pProcess->kill();
             setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_HANGING);
+            m_pProcess->kill();
         }
 
         break;
@@ -183,11 +184,11 @@ void SParentProcess::finishedProcess(int exitCode, QProcess::ExitStatus exitStat
         if (!m_mapReportSummary.contains(analyzedResult.company_num))
             m_mapReportSummary.insert(analyzedResult.company_num, SReportSummary());
         m_mapReportSummary[analyzedResult.company_num].nError++;
-        m_vecError.append(analyzedResult);
+        m_vecError.append(m_erCurrentRow);
     }
 
     emit signalLog(strLog);
-
+    emit signalTerminateEachEvent(analyzedResult.company_num, analyzedResult.state);
     setInnerMode(E_INNER_RUN_MODE::MODE_RUN_EVENTCODE);
     //This may be unnecessary :(
     //pPro->kill();
@@ -333,97 +334,25 @@ QString SParentProcess::makeLog(const SError& _error)
     return str;
 }
 
-
-/*
-E_INFO SParentProcess::analyzeStdOut(const QString& _str, QString& _resultLog)
+void SParentProcess::slotTerminateError(const SError &_error)
 {
-    E_INFO info;
-    QString strLog = makeLog(_str);
+    setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_TERMINATE);
+    emit signalLog(makeLog(_error));
+    emit signalTerminate();
+}
 
-
-    QStringList slstdOut = _str.split(SPLIT_KEYWORD);
+bool SParentProcess::isUserAbort()
+{
+    return m_bUserAbort;
 }
 
 
-QString SParentProcess::makeLog(const QString& _str)
+void SParentProcess::setCurrentEffectRow(const SEffectRow& _row)
 {
-    QString strLog;
-    if (_str.trimmed().size() < 5) // may be timeout case
-    {
-        strLog += "x ";
-        strLog += m_erCurrentRow.company_name + " ";
-        strLog += m_erCurrentRow.eventcode + " ";
-        strLog += m_erCurrentRow.url + "\n";
-        strLog += "ERRORCODE:" + ERROR_MESSAGE[E_ERROR_CODE::TIMEOUT];
-
-        m_vecError.append(SError(E_CRAWL_STATE::FAIL, m_erCurrentRow.company_num,
-                          m_erCurrentRow.platformname_num, m_erCurrentRow.eventcode,
-                          m_erCurrentRow.url, E_ERROR_CODE::TIMEOUT, ""));
-
-        if (!m_mapReportSummary.contains(m_erCurrentRow.company_num))
-            m_mapReportSummary.insert(m_erCurrentRow.company_num, SReportSummary());
-        m_mapReportSummary[m_erCurrentRow.company_num].nError++;
-
-        return strLog;
-    }
-    else if (_str.trimmed().at(0) != 'o' && _str.trimmed().at(0) != 'O' &&
-             _str.trimmed().at(0) != 'x' && _str.trimmed().at(0) != 'X')
-    {
-        strLog += "? ";
-        strLog += m_erCurrentRow.company_name + " ";
-        strLog += m_erCurrentRow.eventcode + " ";
-        strLog += m_erCurrentRow.url + " ";
-        strLog += "ERRORCODE:" + ERROR_MESSAGE[E_ERROR_CODE::UNKNOWN_ERROR] + " ";
-        strLog += "ERRORMSG:" + _str.left(200);
-
-        if (!m_mapReportSummary.contains(m_erCurrentRow.company_num))
-            m_mapReportSummary.insert(m_erCurrentRow.company_num, SReportSummary());
-        m_mapReportSummary[m_erCurrentRow.company_num].nError++;
-
-        return strLog;
-    }
-
-    QStringList slLog = strLog.split(SPLIT_KEYWORD);
-
-    if (slLog.size() < 2)
-    {
-        strLog += "? ";
-        strLog += m_erCurrentRow.company_name + " ";
-        strLog += m_erCurrentRow.eventcode + " ";
-        strLog += m_erCurrentRow.url + " ";
-        strLog += "ERRORCODE:" + ERROR_MESSAGE[E_ERROR_CODE::UNKNOWN_ERROR] + " ";
-        strLog += "ERRORMSG:" + _str.left(200);
-
-        if (!m_mapReportSummary.contains(m_erCurrentRow.company_num))
-            m_mapReportSummary.insert(m_erCurrentRow.company_num, SReportSummary());
-        m_mapReportSummary[m_erCurrentRow.company_num].nError++;
-
-        return strLog;
-    }
-
-    else if (slLog.size() > 2 && (slLog.at(0).trimmed() == 'o' ||
-                             slLog.at(0).trimmed() == 'O'))
-    {
-        strLog += slLog.at(0) + " ";
-        strLog += m_erCurrentRow.company_name + " ";
-        for (int i = 1; i < slLog.size(); ++i)
-            strLog += slLog.at(i) + " ";
-
-        if (!m_mapReportSummary.contains(m_erCurrentRow.company_num))
-            m_mapReportSummary.insert(m_erCurrentRow.company_num, SReportSummary());
-        m_mapReportSummary[m_erCurrentRow.company_num].nError++;
-
-        return strLog;
-    }
-
-    else if (slLog.size() > 2 && (slLog.at(0).trimmed() == 'x' ||
-                                  slLog.at(0).trimmed() == 'X'))
-    {
-        strLog += slLog.at(0)
-        str
-    }
-
-    strLog = slLog.join(" ");
-    return strLog;
+    m_erCurrentRow = _row;
+}
+
+void SParentProcess::setCurrentEffectRow(SEffectRow&& _row)
+{
+    m_erCurrentRow = std::move(_row);
 }
-*/

EffectUI/sparentprocess.h

@@ -14,35 +14,53 @@ class SParentProcess: public QObject
 {
     Q_OBJECT
 
-private:
-    enum class E_INNER_RUN_MODE:unsigned short;
+protected:
+    enum class E_INNER_RUN_MODE:unsigned short
+    {
+        MODE_WAIT = 0,
+        MODE_RUN_INIT,
+        MODE_RUN_EVENTCODE,
+        MODE_WAIT_INIT,
+        MODE_WAIT_EVENTCODE,
+        MODE_WAIT_TERMINATE,
+        MODE_WAIT_HANGING,
+        MODE_FINISH = MODE_WAIT
+    };
 
 
 public:
     SParentProcess();
     virtual void setList(const QVector<int>& _list) = 0;
     virtual void setList(QVector<int>&& _list) = 0;
-    virtual void setList(const QVector<SError>& _list) = 0;
-    virtual void setList(QVector<SError>&& _list) = 0;
+    virtual void setList(const QVector<SEffectRow>& _list) = 0;
+    virtual void setList(QVector<SEffectRow>&& _list) = 0;
     virtual void runInit() = 0;
     virtual void runEventCode() = 0;
     virtual void clear();
-    QVector<SError> getErrorList() const;
+    QVector<SEffectRow> getErrorList() const;
     SReportSummary getReportSummary(int _id) const;
     QMap<int, SReportSummary> getReportSummary() const;
     SError getError() const;
     bool isWaiting() const;
     void setModeWait();
-    void runProcess();
+
 
 private:
+    SError analyzeStdOut(const QString& _str);
+    QString makeLog(const SError& _error);
+
+
+protected:
+    QStringList getProcessArguments(const SEffectRow& _row) const;
+    QStringList getProcessArguments(SEffectRow&& _row) const;
+
     void setError(const SError& _error);
     void setError(SError&& _error);
     void setInnerMode(E_INNER_RUN_MODE _mode);
-    QStringList getProcessArguments(const SEffectRow& _row) const;
-    QStringList getProcessArguments(SEffectRow&& _row) const;
-    SError analyzeStdOut(const QString& _str);
-    QString makeLog(const SError& _error);
+    bool isUserAbort();
+    void setCurrentEffectRow(const SEffectRow& _row);
+    void setCurrentEffectRow(SEffectRow&& _row);
+    void runProcess(QStringList _arguments);
 
 
 public slots:
@@ -53,17 +71,23 @@ public slots:
 
 signals:
     void signalUserAbort();
-    void signalTerminateError();
+    void signalTerminateError(const SError& _error);
     void signalTerminateNormal();
     void signalTerminate();
     void signalLog(const QString& _log);
+    void signalTerminateEachEvent(int _company, E_CRAWL_STATE _state);
+
+
+protected slots:
+    void slotTerminateError(const SError& _error);
+
 
 private:
     QProcess* m_pProcess;
 
     E_INNER_RUN_MODE m_eInnerMode;
     SEffectRow m_erCurrentRow;
-    QVector<SError> m_vecError;
+    QVector<SEffectRow> m_vecError;
     bool m_bRunning;
     unsigned int nTime;
     SError m_error;

EffectUI/srunninglistwidget.cpp

@@ -300,13 +300,14 @@ void SRunningListWidget::setOutDate(int _id)
         item->setText(QDateTime::currentDateTime().toString("OutDate"));
 }
 
-void SRunningListWidget::setInfo(int _id, int _ok, int _error, int _no, int _total)
+void SRunningListWidget::setInfo(int _id, int _ok, int _error, int _active_event, int _all_active_group, int _total)
 {
     QTableWidgetItem* item = findWidgetItembyID(_id, E_TABLE_HEADER::INFOMATION);
     if (item)
         item->setText(QString::number(_ok) + "/"
                       + QString::number(_error) + "/"
-                      + QString::number(_no) + "/"
+                      + QString::number(_active_event) + "/"
+                      + QString::number(_all_active_group) + "/"
                       + QString::number(_total));
 }
 
@@ -326,7 +327,8 @@ void SRunningListWidget::setInfoErrortoOk(int _id)
 
         item->setText(QString::number(nOk) + "/"
                       + QString::number(nError) + "/"
-                      + slInfo.at(static_cast<int>(E_INFO::NO)) + "/"
+                      + slInfo.at(static_cast<int>(E_INFO::ACTIVE_EVENT)) + "/"
+                      + slInfo.at(static_cast<int>(E_INFO::ALL_ACTIVE_GROUP)) + "/"
                       + slInfo.at(static_cast<int>(E_INFO::TOTAL)));
     }
 }

EffectUI/srunninglistwidget.h

@@ -49,7 +49,7 @@ public slots:
     void setWaiting(int _id);
     void setOutDate(int _id);
     void setComplete(int _id);
-    void setInfo(int _id, int _ok = 0, int _error = 0, int _no = 0, int _total = 0);
+    void setInfo(int _id, int _ok = 0, int _error = 0, int _active_event = 0, int _all_active_group = 0, int _total = 0);
     void setInfoErrortoOk(int _id);
     void removeSelectedList();
 

EffectUI/srunningprocess.cpp

@@ -0,0 +1,153 @@
+#include "srunningprocess.h"
+#include <QTimer>
+
+namespace{
+const int ONE_SECOND = 1000; // 1 second
+const int HALF_SECOND = 500; // 0.5 second
+}
+
+
+SRunningProcess::SRunningProcess():
+    m_pTimer(new QTimer(this)), m_pErrorProcess(new SErrorProcess),
+    m_pCompanyProcess(new SCompanyProcess), m_eMode(E_PROCESS_MODE::WAIT),
+    m_pCurrentProcess(nullptr)
+{
+    m_pTimer->setInterval(ONE_SECOND);
+    initConnect();
+}
+
+bool SRunningProcess::isRunning()
+{
+    if (m_pCurrentProcess == nullptr && !m_pTimer->isActive())
+        return true;
+    else
+        return m_pCurrentProcess->isWaiting() && !m_pTimer->isActive();
+}
+
+void SRunningProcess::setList(const QVector<SEffectRow>& _list)
+{
+    if (!isRunning())
+    {
+        m_pCurrentProcess = m_pErrorProcess;
+        m_pCurrentProcess->setList(_list);
+    }
+}
+
+void SRunningProcess::setList(QVector<SEffectRow>&& _list)
+{
+    if (!isRunning())
+    {
+        m_pCurrentProcess = m_pErrorProcess;
+        m_pCurrentProcess->setList(std::move(_list));
+    }
+}
+
+void SRunningProcess::setList(const QVector<int>& _list)
+{
+    if (!isRunning())
+    {
+        m_pCurrentProcess = m_pCompanyProcess;
+        m_pCurrentProcess->setList(_list);
+    }
+}
+
+void SRunningProcess::setList(QVector<int>&& _list)
+{
+    if (!isRunning())
+    {
+        m_pCurrentProcess = m_pCompanyProcess;
+        m_pCurrentProcess->setList(std::move(_list));
+    }
+}
+
+
+template <typename T>
+void SRunningProcess::start(QVector<T>&& _list)
+{
+    if (!isRunning())
+    {
+        setList(std::forward(_list));
+        start();
+    }
+}
+
+void SRunningProcess::start()
+{
+    if (!isRunning())
+    {
+        m_pTimer->start();
+        emit signalLog("Start Effect Process");
+    }
+}
+
+void SRunningProcess::update()
+{
+    m_pCurrentProcess->update();
+}
+
+void SRunningProcess::slotLog(const QString &_strLog)
+{
+    emit signalLog(_strLog);
+}
+
+void SRunningProcess::terminate()
+{
+    m_pTimer->stop();
+    m_pCurrentProcess->setModeWait();
+    emit signalLog("Terminate Process");
+}
+
+void SRunningProcess::slotUserAbort()
+{
+    terminate();
+    emit signalUserAbort();
+}
+
+void SRunningProcess::stop()
+{
+    m_pCurrentProcess->stop();
+}
+
+void SRunningProcess::slotCompanyComplete(int _num)
+{
+    SReportSummary summary = m_pCurrentProcess->getReportSummary(_num);
+    emit signalCompanyComplete(_num, summary);
+}
+
+void SRunningProcess::slotSuccessErrorCompany(int _num)
+{
+    emit signalSuccessErrorCompany(_num);
+}
+
+void SRunningProcess::slotTerminateError()
+{
+    terminate();
+    SError error = m_pCurrentProcess->getError();
+    emit signalTerminateError(error);
+}
+
+void SRunningProcess::slotTerminateNormal()
+{
+    terminate();
+    QVector<SEffectRow> errors = m_pCurrentProcess->getErrorList();
+    QMap<int, SReportSummary> reportSummary = m_pCurrentProcess->getReportSummary();
+    emit signalTerminateNormal(errors, reportSummary);
+}
+
+void SRunningProcess::initConnect()
+{
+    QObject::connect(&(*m_pTimer), &QTimer::timeout, this, &SRunningProcess::update);
+
+    QObject::connect(&(*m_pCompanyProcess), &SCompanyProcess::signalLog, this, &SRunningProcess::slotLog);
+    QObject::connect(&(*m_pErrorProcess), &SErrorProcess::signalLog, this, &SRunningProcess::slotLog);
+
+    QObject::connect(&(*m_pCompanyProcess), &SCompanyProcess::signalTerminate, this, &SRunningProcess::slotTerminateError);
+    QObject::connect(&(*m_pErrorProcess), &SErrorProcess::signalTerminate, this, &SRunningProcess::slotTerminateError);
+
+    QObject::connect(&(*m_pCompanyProcess), &SCompanyProcess::signalTerminateNormal, this, &SRunningProcess::slotTerminateNormal);
+    QObject::connect(&(*m_pErrorProcess), &SErrorProcess::signalTerminateNormal, this, &SRunningProcess::slotTerminateNormal);
+
+    QObject::connect(&(*m_pCompanyProcess), &SCompanyProcess::signalTerminateCompany, this, &SRunningProcess::slotCompanyComplete);
+    QObject::connect(&(*m_pErrorProcess), &SErrorProcess::signalTerminateCompany, this, &SRunningProcess::slotSuccessErrorCompany);
+}
+

EffectUI/srunningprocess.h

@@ -0,0 +1,68 @@
+#ifndef SRUNNINGPROCESS
+#define SRUNNINGPROCESS
+#include <QObject>
+#include <memory>
+#include <QVector>
+#include "sutilclass.h"
+#include <QTimer>
+#include "scompanyprocess.h"
+#include "serrorprocess.h"
+
+class SRunningProcess:public QObject
+{
+    Q_OBJECT
+private:
+    enum class E_PROCESS_MODE
+    {
+        WAIT = 0,
+        RUN
+    };
+
+public:
+    SRunningProcess();
+    bool isRunning();
+    void setList(const QVector<SEffectRow>& _list);
+    void setList(QVector<SEffectRow>&& _list);
+    void setList(const QVector<int>& _list);
+    void setList(QVector<int>&& _list);
+    template <typename T>
+    void start(QVector<T>&& _list);
+
+public slots:
+    void update();
+    void stop();
+    void start();
+
+private:
+    void terminate();
+    void initConnect();
+
+private slots:
+    void slotLog(const QString& _strLog);
+    void slotUserAbort();
+    void slotCompanyComplete(int _num);
+    void slotSuccessErrorCompany(int _num);
+    void slotTerminateError();
+    void slotTerminateNormal();
+
+
+signals:
+    void signalLog(const QString& _strLog);
+    void signalUserAbort();
+    void signalTerminateNormal(const QVector<SEffectRow>& _error,
+                         const QMap<int, SReportSummary>& _report);
+    void signalTerminateError(const SError& _error);
+    void signalCompanyComplete(int _num, const SReportSummary& summary);
+    void signalSuccessErrorCompany(int _num);
+
+private:
+    std::unique_ptr<QTimer> m_pTimer;
+    std::shared_ptr<SErrorProcess> m_pErrorProcess;
+    std::shared_ptr<SCompanyProcess> m_pCompanyProcess;
+    E_PROCESS_MODE m_eMode;
+
+    std::shared_ptr<SParentProcess> m_pCurrentProcess;
+};
+
+#endif // SRUNNINGPROCESS
+

EffectUI/sutilclass.h

@@ -62,14 +62,16 @@ struct SReportSummary
 {
     unsigned int nOk;
     unsigned int nError;
-    unsigned int nNo;
+    unsigned int nActiveEventCode;
+    unsigned int nAllGroupEvent;
     unsigned int nTotal;
     SReportSummary(unsigned int _ok = 0, unsigned int _error = 0,
-                   unsigned int _no = 0, unsigned int _total = 0
-                   ):nOk(_ok), nError(_error), nNo(_no), nTotal(_total) {}
+                   unsigned int _active_event_code = 0, unsigned int _all_group_event = 0,
+                   unsigned int _total = 0
+                   ):nOk(_ok), nError(_error), nActiveEventCode(_active_event_code),
+        nAllGroupEvent(_all_group_event), nTotal(_total) {}
 };
 
-
 struct SError
 {
     E_CRAWL_STATE state;
@@ -81,13 +83,14 @@ struct SError
     QString str_error;
     SError();
 
-    SError(E_ERROR_CODE _error_code): company_num(-1), platformname_num(-1), error_code(_error_code)
+    SError(E_ERROR_CODE _error_code): state(E_CRAWL_STATE::FAIL), company_num(-1), platformname_num(-1), error_code(_error_code)
     {
 
     }
 
     template <typename T>
-    SError(E_ERROR_CODE _error_code, T&& _str_error): company_num(-1), platformname_num(-1),
+    SError(E_ERROR_CODE _error_code, T&& _str_error): state(E_CRAWL_STATE::FAIL),
+        company_num(-1), platformname_num(-1),
         error_code(_error_code), str_error(std::forward<T>(_str_error))
     {
 
@@ -144,7 +147,8 @@ enum class E_INFO
 {
     OK = 0,
     ERROR,
-    NO,
+    ACTIVE_EVENT,
+    ALL_ACTIVE_GROUP,
     TOTAL
 };
 

EffectUI/widget.cpp

@@ -3,6 +3,7 @@
 #include "scompanylistwidget.h"
 #include "srunninglistwidget.h"
 #include "sadddelwidget.h"
+#include "slogwidget.h"
 #include <QHBoxLayout>
 
 Widget::Widget(QWidget *parent) :
@@ -13,12 +14,14 @@ Widget::Widget(QWidget *parent) :
     SCompanyListWidget *c = new SCompanyListWidget;
     SRunningListWidget *d = new SRunningListWidget;
     SAddDelWidget *e = new SAddDelWidget;
+    SLogWidget *f = new SLogWidget;
     QHBoxLayout* mainLayout = new QHBoxLayout(this);
 
     mainLayout->addWidget(c);
     mainLayout->addWidget(e);
 
     mainLayout->addWidget(d);
+    mainLayout->addWidget(f);
 
     connect(e, &SAddDelWidget::signalClickedAddBtn, [&c, &d](){
         d->addList(c->getSelectedList());
@@ -29,6 +32,7 @@ Widget::Widget(QWidget *parent) :
     });
 
     setLayout(mainLayout);
+    setWindowTitle("EffectUI " + QString::number(QCoreApplication::applicationPid()));
 
     show();