sparentprocess 클래스 추가

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

EffectUI/EffectUI.pro

@@ -20,7 +20,9 @@ SOURCES += main.cpp\
     sutilclass.cpp \
     srunninglistwidget.cpp \
     stimer.cpp \
-    sadddelwidget.cpp
+    sadddelwidget.cpp \
+    srunprocess.cpp \
+    sparentprocess.cpp
 
 HEADERS  += widget.h \
     scompanylistwidget.h \
@@ -28,6 +30,8 @@ HEADERS  += widget.h \
     sutilclass.h \
     srunninglistwidget.h \
     stimer.h \
-    sadddelwidget.h
+    sadddelwidget.h \
+    srunprocess.h \
+    sparentprocess.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-06T19:12:06. -->
+<!-- Written by QtCreator 3.3.0, 2016-10-17T19:05:38. -->
 <qtcreator>
  <data>
   <variable>EnvironmentId</variable>
@@ -8,7 +8,7 @@
  </data>
  <data>
   <variable>ProjectExplorer.Project.ActiveTarget</variable>
-  <value type="int">0</value>
+  <value type="int">3</value>
  </data>
  <data>
   <variable>ProjectExplorer.Project.EditorSettings</variable>
@@ -620,7 +620,7 @@
    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Desktop Qt 5.4.0 MSVC2013 64bit</value>
    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Desktop Qt 5.4.0 MSVC2013 64bit</value>
    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">{4a73e1a8-867f-4a8f-a70a-a3bb186185e4}</value>
-   <value type="int" key="ProjectExplorer.Target.ActiveBuildConfiguration">0</value>
+   <value type="int" key="ProjectExplorer.Target.ActiveBuildConfiguration">1</value>
    <value type="int" key="ProjectExplorer.Target.ActiveDeployConfiguration">0</value>
    <value type="int" key="ProjectExplorer.Target.ActiveRunConfiguration">0</value>
    <valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.0">
@@ -781,15 +781,16 @@
      <value type="int">13</value>
      <value type="int">14</value>
     </valuelist>
-    <value type="int" key="PE.EnvironmentAspect.Base">-1</value>
+    <value type="int" key="PE.EnvironmentAspect.Base">2</value>
     <valuelist type="QVariantList" key="PE.EnvironmentAspect.Changes"/>
-    <value type="QString" key="ProjectExplorer.CustomExecutableRunConfiguration.Arguments"></value>
+    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">EffectUI</value>
-    <value type="QString" key="ProjectExplorer.CustomExecutableRunConfiguration.Executable"></value>
-    <value type="bool" key="ProjectExplorer.CustomExecutableRunConfiguration.UseTerminal">false</value>
-    <value type="QString" key="ProjectExplorer.CustomExecutableRunConfiguration.WorkingDirectory">%{buildDir}</value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Custom Executable</value>
     <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
-    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.CustomExecutableRunConfiguration</value>
+    <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4RunConfiguration:C:/source/EffectUI/EffectUI.pro</value>
+    <value type="QString" key="Qt4ProjectManager.Qt4RunConfiguration.CommandLineArguments"></value>
+    <value type="QString" key="Qt4ProjectManager.Qt4RunConfiguration.ProFile">EffectUI.pro</value>
+    <value type="bool" key="Qt4ProjectManager.Qt4RunConfiguration.UseDyldImageSuffix">false</value>
+    <value type="bool" key="Qt4ProjectManager.Qt4RunConfiguration.UseTerminal">false</value>
+    <value type="QString" key="Qt4ProjectManager.Qt4RunConfiguration.UserWorkingDirectory"></value>
     <value type="uint" key="RunConfiguration.QmlDebugServerPort">3768</value>
     <value type="bool" key="RunConfiguration.UseCppDebugger">false</value>
     <value type="bool" key="RunConfiguration.UseCppDebuggerAuto">true</value>

EffectUI/scompanylistwidget.cpp

@@ -111,12 +111,14 @@ void SCompanyListWidget::initTableWidget()
 
 void SCompanyListWidget::slotClickedItem()
 {
+    /*
     qDebug() << "signalClickedItem";
     auto kkk = getSelectedList();
     foreach (auto& k, kkk)
     {
         qDebug() << k[0].text() << ", " << k[1].text() << ", " << k[2].text() << ", " << k[3].text();
     }
+    */
 
     emit signalClickedItem();
 }
@@ -127,6 +129,13 @@ void SCompanyListWidget::resetTableHeader()
     m_ptableWidget->setHorizontalHeaderLabels(*m_pslTableHeader);
 }
 
+
+void SCompanyListWidget::enableTableWidget(bool _enable)
+{
+    m_ptableWidget->setEnabled(_enable);
+}
+
+
 QVBoxLayout* SCompanyListWidget::getLayout() const
 {
     return m_playout;
@@ -297,6 +306,8 @@ QVector<QVector<QTableWidgetItem>> SCompanyListWidget::getSelectedList() const
     auto modelIndexes = m_ptableWidget->selectionModel()->selectedRows();
 
     foreach (auto& modelIndex, modelIndexes)
+    {
+        if (!m_ptableWidget->isRowHidden(modelIndex.row()))
         {
             QVector<QTableWidgetItem> item;
             item.append(QTableWidgetItem(*m_ptableWidget->item(modelIndex.row(), static_cast<int>(E_TABLE_HEADER::COMPANY))));
@@ -305,6 +316,7 @@ QVector<QVector<QTableWidgetItem>> SCompanyListWidget::getSelectedList() const
             item.append(STableWidgetItem(*m_ptableWidget->item(modelIndex.row(), static_cast<int>(E_TABLE_HEADER::EVENT_NUM))));
             items.append(item);
         }
+    }
     return items;
 }
 

EffectUI/scompanylistwidget.h

@@ -34,6 +34,7 @@ public slots:
     void refresh();
     void search();
     void slotClickedItem();
+    void enableTableWidget(bool _enable);
 
 signals:
     void signalClickedItem();

EffectUI/sparentprocess.cpp

@@ -0,0 +1,429 @@
+#include "sparentprocess.h"
+#include "sutilfunction.h"
+#include <QThread>
+#include <QString>
+
+extern QString ERROR_MESSAGE[];
+
+namespace
+{
+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)));
+}
+
+void SParentProcess::clear()
+{
+    m_vecError.clear();
+    m_mapReportSummary.clear();
+    m_erCurrentRow = SEffectRow();
+    m_error = SError();
+}
+
+void SParentProcess::setInnerMode(E_INNER_RUN_MODE _mode)
+{
+    m_eInnerMode = _mode;
+}
+
+QVector<SError> SParentProcess::getErrorList() const
+{
+    return m_vecError;
+}
+
+SReportSummary SParentProcess::getReportSummary(int _id) const
+{
+    return m_mapReportSummary[_id];
+}
+
+QMap<int, SReportSummary> SParentProcess::getReportSummary() const
+{
+    return m_mapReportSummary;
+}
+
+
+SError SParentProcess::getError() const
+{
+    return m_error;
+}
+
+bool SParentProcess::isWaiting() const
+{
+    return m_eInnerMode == E_INNER_RUN_MODE::MODE_WAIT;
+}
+
+void SParentProcess::setModeWait()
+{
+    m_eInnerMode = E_INNER_RUN_MODE::MODE_WAIT;
+}
+
+QStringList SParentProcess::getProcessArguments(const SEffectRow& _row) const
+{
+    return QStringList();
+}
+
+QStringList SParentProcess::getProcessArguments(SEffectRow&& _row) const
+{
+    return QStringList();
+}
+
+void SParentProcess::runProcess()
+{
+
+}
+
+void SParentProcess::setError(const SError& _error)
+{
+    m_error = _error;
+}
+
+void SParentProcess::setError(SError&& _error)
+{
+    m_error = std::move(_error);
+}
+
+void SParentProcess::stop()
+{
+    m_bUserAbort = true;
+}
+
+void SParentProcess::update()
+{
+    switch(m_eInnerMode)
+    {
+
+    case E_INNER_RUN_MODE::MODE_WAIT:
+    {
+        setInnerMode(E_INNER_RUN_MODE::MODE_RUN_INIT);
+        break;
+    }
+
+    case E_INNER_RUN_MODE::MODE_RUN_INIT:
+    {
+        runInit();
+        break;
+    }
+
+    case E_INNER_RUN_MODE::MODE_RUN_EVENTCODE:
+    {
+        runEventCode();
+        break;
+    }
+
+    case E_INNER_RUN_MODE::MODE_WAIT_EVENTCODE:
+    {
+        if (++nTime >= TIMEOUT)
+        {
+            m_pProcess->kill();
+            setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_HANGING);
+        }
+
+        break;
+    }
+
+    case E_INNER_RUN_MODE::MODE_WAIT_INIT:
+    {
+        break;
+    }
+
+    case E_INNER_RUN_MODE::MODE_WAIT_TERMINATE:
+    {
+        break;
+    }
+
+    case E_INNER_RUN_MODE::MODE_WAIT_HANGING:
+    {
+        break;
+    }
+
+    }
+}
+
+void SParentProcess::finishedProcess(int exitCode, QProcess::ExitStatus exitStatus)
+{
+    if (m_bUserAbort)
+    {
+        setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_HANGING);
+        emit signalUserAbort();
+        return;
+    }
+    QProcess *pPro = (QProcess*)sender();
+    QThread::msleep(100);
+    QString str = pPro->readAllStandardOutput();
+
+    SError analyzedResult = analyzeStdOut(str);
+    QString strLog = makeLog(analyzedResult);
+
+    if (analyzedResult.state == E_CRAWL_STATE::OK)
+    {
+        if (!m_mapReportSummary.contains(analyzedResult.company_num))
+            m_mapReportSummary.insert(analyzedResult.company_num, SReportSummary());
+        m_mapReportSummary[analyzedResult.company_num].nOk++;
+        //add emit signal Finished success?
+    }
+    else
+    {
+        if (!m_mapReportSummary.contains(analyzedResult.company_num))
+            m_mapReportSummary.insert(analyzedResult.company_num, SReportSummary());
+        m_mapReportSummary[analyzedResult.company_num].nError++;
+        m_vecError.append(analyzedResult);
+    }
+
+    emit signalLog(strLog);
+
+    setInnerMode(E_INNER_RUN_MODE::MODE_RUN_EVENTCODE);
+    //This may be unnecessary :(
+    //pPro->kill();
+}
+
+
+SError SParentProcess::analyzeStdOut(const QString& _str)
+{
+    SError errorResult;
+    if (_str.trimmed().size() < 5) // may be timeout case
+    {
+        errorResult.state = E_CRAWL_STATE::FAIL;
+        errorResult.company_num = m_erCurrentRow.company_num;
+        errorResult.event_code = m_erCurrentRow.eventcode;
+        errorResult.platformname_num = m_erCurrentRow.platformname_num;
+        errorResult.error_code = E_ERROR_CODE::TIMEOUT;
+        errorResult.url = m_erCurrentRow.url;
+        errorResult.str_error = _str;
+
+        return errorResult;
+    }
+
+
+    // unknown type log
+    // This result is treated like unknown error.
+    else if (_str.trimmed().at(0) != 'o' && _str.trimmed().at(0) != 'O' &&
+             _str.trimmed().at(0) != 'x' && _str.trimmed().at(0) != 'X')
+    {
+        errorResult.state = E_CRAWL_STATE::FAIL;
+        errorResult.company_num = m_erCurrentRow.company_num;
+        errorResult.event_code = m_erCurrentRow.eventcode;
+        errorResult.platformname_num = m_erCurrentRow.platformname_num;
+        errorResult.error_code = E_ERROR_CODE::UNKNOWN_ERROR;
+        errorResult.url = m_erCurrentRow.url;
+        errorResult.str_error = _str.trimmed().left(200);
+
+        return errorResult;
+    }
+
+    else
+    {
+        QStringList slLog = _str.split(SPLIT_KEYWORD);
+
+        if (slLog.size() < 3)
+        {
+            errorResult.state = E_CRAWL_STATE::FAIL;
+            errorResult.company_num = m_erCurrentRow.company_num;
+            errorResult.event_code = m_erCurrentRow.eventcode;
+            errorResult.platformname_num = m_erCurrentRow.platformname_num;
+            errorResult.error_code = E_ERROR_CODE::UNKNOWN_ERROR;
+            errorResult.url = m_erCurrentRow.url;
+            errorResult.str_error = _str.trimmed().left(200);
+
+            return errorResult;
+
+        }
+        else if ((slLog.at(0).trimmed() == "o" || slLog.at(0).trimmed() == "O"))
+        {
+            errorResult.state = E_CRAWL_STATE::OK;
+            errorResult.company_num = m_erCurrentRow.company_num;
+            errorResult.event_code = m_erCurrentRow.eventcode;
+            errorResult.url = m_erCurrentRow.url;
+            /*
+            errorResult.event_code = slLog.at(static_cast<int>(E_LOG_COLUMN::EVENT_CODE));
+            errorResult.url = slLog.at(static_cast<int>(E_LOG_COLUMN::URL));
+            */
+            return errorResult;
+        }
+        else if ((slLog.at(0).trimmed() == "x" || slLog.at(0).trimmed() == "X"))
+        {
+            errorResult.state = E_CRAWL_STATE::FAIL;
+            errorResult.company_num = m_erCurrentRow.company_num;
+            errorResult.platformname_num = m_erCurrentRow.platformname_num;
+
+            /*
+            errorResult.event_code = slLog.at(static_cast<int>(E_LOG_COLUMN::EVENT_CODE));
+            errorResult.url = slLog.at(static_cast<int>(E_LOG_COLUMN::URL));
+            */
+
+            switch (slLog.size())
+            {
+            case static_cast<int>(E_LOG_COLUMN::ERROR_MSG) + 1:
+            {
+                errorResult.str_error = slLog.at(
+                            static_cast<int>(E_LOG_COLUMN::ERROR_MSG)).trimmed();
+            }
+            case static_cast<int>(E_LOG_COLUMN::ERROR_CODE) + 1:
+            {
+                errorResult.error_code = strErrorCodeToEnumErrorCode(
+                            slLog.at(static_cast<int>(E_LOG_COLUMN::ERROR_CODE)).trimmed());
+            }
+            case static_cast<int>(E_LOG_COLUMN::URL) + 1:
+            {
+                errorResult.event_code = slLog.at(
+                            static_cast<int>(E_LOG_COLUMN::EVENT_CODE)).trimmed();
+                errorResult.url = slLog.at(
+                            static_cast<int>(E_LOG_COLUMN::URL)).trimmed();
+            }
+            }
+            return errorResult;
+        }
+        else
+        {
+            errorResult.state = E_CRAWL_STATE::FAIL;
+            errorResult.company_num = m_erCurrentRow.company_num;
+            errorResult.event_code = m_erCurrentRow.eventcode;
+            errorResult.platformname_num = m_erCurrentRow.platformname_num;
+            errorResult.error_code = E_ERROR_CODE::UNKNOWN_ERROR;
+            errorResult.url = m_erCurrentRow.url;
+            errorResult.str_error = _str.trimmed().left(200);
+
+            return errorResult;
+
+        }
+    }
+}
+
+
+QString SParentProcess::makeLog(const SError& _error)
+{
+    QString str;
+    switch (_error.state)
+    {
+    case E_CRAWL_STATE::OK:
+    {
+        str += "o ";
+        str += m_erCurrentRow.company_name + " ";
+        str += _error.event_code + " ";
+        str += _error.url + " ";
+        break;
+    }
+    case E_CRAWL_STATE::FAIL:
+    {
+        str += "x ";
+        str += m_erCurrentRow.company_name + " ";
+        str += _error.event_code + " ";
+        str += _error.url + "\n";
+        str += "  ERROR:" + errorCodeToString(_error.error_code) + "\n";
+        str += "  ERRORMSG:" + _error.str_error;
+        break;
+    }
+    }
+    return str;
+}
+
+
+/*
+E_INFO SParentProcess::analyzeStdOut(const QString& _str, QString& _resultLog)
+{
+    E_INFO info;
+    QString strLog = makeLog(_str);
+
+
+    QStringList slstdOut = _str.split(SPLIT_KEYWORD);
+}
+
+
+QString SParentProcess::makeLog(const QString& _str)
+{
+    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;
+}
+*/

EffectUI/sparentprocess.h

@@ -0,0 +1,76 @@
+#ifndef SPARENTPROCESS
+#define SPARENTPROCESS
+#include <QObject>
+#include "sutilclass.h"
+#include <QVector>
+#include <QMap>
+#include <QProcess>
+
+class QStringList;
+class QString;
+
+
+class SParentProcess: public QObject
+{
+    Q_OBJECT
+
+private:
+    enum class E_INNER_RUN_MODE:unsigned short;
+
+
+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 runInit() = 0;
+    virtual void runEventCode() = 0;
+    virtual void clear();
+    QVector<SError> getErrorList() const;
+    SReportSummary getReportSummary(int _id) const;
+    QMap<int, SReportSummary> getReportSummary() const;
+    SError getError() const;
+    bool isWaiting() const;
+    void setModeWait();
+    void runProcess();
+
+private:
+    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);
+
+
+public slots:
+    void stop();
+    void update();
+    void finishedProcess(int exitCode, QProcess::ExitStatus exitStatus);
+
+
+signals:
+    void signalUserAbort();
+    void signalTerminateError();
+    void signalTerminateNormal();
+    void signalTerminate();
+    void signalLog(const QString& _log);
+
+private:
+    QProcess* m_pProcess;
+
+    E_INNER_RUN_MODE m_eInnerMode;
+    SEffectRow m_erCurrentRow;
+    QVector<SError> m_vecError;
+    bool m_bRunning;
+    unsigned int nTime;
+    SError m_error;
+    bool m_bUserAbort;
+    QMap<int, SReportSummary> m_mapReportSummary;
+};
+
+
+#endif // SPARENTPROCESS
+

EffectUI/srunninglistwidget.cpp

@@ -14,10 +14,12 @@
 #include <QDebug>
 #include <QDateTime>
 
+/*
 namespace
 {
 const QString strDatabaseName("runninglist");
 }
+*/
 
 enum class SRunningListWidget::E_TABLE_HEADER
 {
@@ -26,6 +28,7 @@ enum class SRunningListWidget::E_TABLE_HEADER
     END_DATE,
     EVENT_NUM,
     STATUS,
+    INFOMATION,
     LAST_UPDATE_TIME,
     MAX
 };
@@ -38,9 +41,9 @@ SRunningListWidget::SRunningListWidget(QWidget* parent) :
     m_playout(new QVBoxLayout(this)), m_pslTableHeader(new QStringList)
 {
     *m_pslTableHeader << "Company" << "Start date" << "End date"
-                      << "Event Num" << "Status" << "Last Update Time";
+                      << "Event Num" << "Status" << "Info" << "Update Time";
     initButton();
-    initDatabase();
+    //initDatabase();
     initTableWidget();
     initLayout();
     resetTableHeader();
@@ -63,19 +66,19 @@ void SRunningListWidget::initButton()
             this, &SRunningListWidget::slotTimerStop);
 }
 
-
+/*
 void SRunningListWidget::initDatabase()
 {
     databaseSetting(strDatabaseName);
 }
-
+*/
 void SRunningListWidget::initTableWidget()
 {
     m_ptableWidget->setColumnCount(m_pslTableHeader->size());
     m_ptableWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
     m_ptableWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
     m_ptableWidget->setSortingEnabled(true);
-    //m_ptableWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+    //m_ptableWidget->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum);
     connect(m_ptableWidget, &QTableWidget::itemSelectionChanged,
             this, &SRunningListWidget::slotClickedItem);
 }
@@ -127,6 +130,7 @@ void SRunningListWidget::removeSelectedList()
     QModelIndexList selectedList = m_ptableWidget->selectionModel()->selectedRows();
     for (int i = selectedList.size() - 1; i >= 0; --i)
     {
+        m_setNumber.remove(selectedList[i].data(Qt::UserRole).toInt());
         m_ptableWidget->removeRow(selectedList[i].row());
     }
 }
@@ -218,6 +222,9 @@ void SRunningListWidget::addList(QVector<QVector<QTableWidgetItem>> items)
         m_ptableWidget->setItem(m_ptableWidget->rowCount() - 1,
                                 static_cast<int>(E_TABLE_HEADER::STATUS),
                                 new QTableWidgetItem(""));
+        m_ptableWidget->setItem(m_ptableWidget->rowCount() - 1,
+                                static_cast<int>(E_TABLE_HEADER::INFOMATION),
+                                new QTableWidgetItem(""));
         m_ptableWidget->setItem(m_ptableWidget->rowCount() - 1,
                                 static_cast<int>(E_TABLE_HEADER::LAST_UPDATE_TIME),
                                 new QTableWidgetItem(""));
@@ -260,6 +267,11 @@ void SRunningListWidget::enableBtnForceStop(bool _enable)
     m_pbtnForceStop->setEnabled(_enable);
 }
 
+void SRunningListWidget::enableTableWidget(bool _enable)
+{
+    m_ptableWidget->setEnabled(_enable);
+}
+
 void SRunningListWidget::setRunning(int _id)
 {
     QTableWidgetItem* item = findWidgetItembyID(_id, E_TABLE_HEADER::STATUS);
@@ -281,6 +293,46 @@ void SRunningListWidget::setComplete(int _id)
         item->setText(QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss"));
 }
 
+void SRunningListWidget::setOutDate(int _id)
+{
+    QTableWidgetItem* item = findWidgetItembyID(_id, E_TABLE_HEADER::STATUS);
+    if (item)
+        item->setText(QDateTime::currentDateTime().toString("OutDate"));
+}
+
+void SRunningListWidget::setInfo(int _id, int _ok, int _error, int _no, 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(_total));
+}
+
+void SRunningListWidget::setInfoErrortoOk(int _id)
+{
+    QTableWidgetItem* item = findWidgetItembyID(_id, E_TABLE_HEADER::INFOMATION);
+    if (item)
+    {
+        QStringList slInfo = item->text().split("/");
+        if (slInfo.size() <= static_cast<int>(E_INFO::TOTAL))
+            return;
+        int nOk = slInfo.at(static_cast<int>(E_INFO::OK)).toInt();
+        int nError = slInfo.at(static_cast<int>(E_INFO::ERROR)).toInt();
+
+        ++nOk;
+        --nError;
+
+        item->setText(QString::number(nOk) + "/"
+                      + QString::number(nError) + "/"
+                      + slInfo.at(static_cast<int>(E_INFO::NO)) + "/"
+                      + slInfo.at(static_cast<int>(E_INFO::TOTAL)));
+    }
+}
+
+
+
 void SRunningListWidget::slotTimerStart()
 {
     qDebug() << "clicked TimerStart()";

EffectUI/srunninglistwidget.h

@@ -30,23 +30,27 @@ public:
 private:
     void initButton();
     void initTableWidget();
-    void initDatabase();
     void initLayout();
     void resetTableHeader();
     QTableWidgetItem* findWidgetItembyID(int _id, E_TABLE_HEADER _header) const;
 
+    //void initDatabase();
 
 public slots:
     void addList(QVector<QVector<QTableWidgetItem>> items);
     QVector<int> getSelectedList() const;
     QVector<int> getAllList() const;
-    void enableBtnTimerStart(bool enable);
+    void enableBtnTimerStart(bool _enable);
-    void enableBtnTimerStop(bool enable);
+    void enableBtnTimerStop(bool _enable);
-    void enableBtnForceStart(bool enable);
+    void enableBtnForceStart(bool _enable);
-    void enableBtnForceStop(bool enable);
+    void enableBtnForceStop(bool _enable);
+    void enableTableWidget(bool _enable);
     void setRunning(int _id);
     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 setInfoErrortoOk(int _id);
     void removeSelectedList();
 
     void slotTimerStart();

EffectUI/srunprocess.cpp

@@ -0,0 +1,379 @@
+#include "srunprocess.h"
+#include "sutilclass.h"
+#include "sutilfunction.h"
+#include <QProcess>
+#include <QTimer>
+#include <QString>
+#include <QSqlDatabase>
+#include <QSqlQuery>
+#include <QSqlError>
+
+
+namespace
+{
+const QString strDatabaseName("processlist");
+const int ONE_SECOND = 1000; // 1 second
+const int HALF_SECOND = 500; // 0.5 second
+}
+
+enum class SRunProcess::E_INNER_RUN_MODE:unsigned short
+{
+    MODE_WAIT = 0,
+    MODE_RUN_INIT,
+    MODE_RUN_EVENTCODE,
+    MODE_WAIT_INIT,
+    MODE_WAIT_EVENTCODE,
+    MODE_FINISH = MODE_WAIT
+};
+
+
+SRunProcess::SRunProcess():m_eRunMode(E_RUN_MODE::MODE_WAIT),
+    m_pTimer(new QTimer(this)), m_pProcess(new QProcess(this)),
+    m_eListMode(E_LIST_MODE::MODE_COMPANY), m_bRun(false),
+    m_eInnerRunMode(E_INNER_RUN_MODE::MODE_WAIT)
+{
+    initDatabase();
+    connect(m_pTimer.get(), &QTimer::timeout, this, &SRunProcess::update);
+}
+
+void SRunProcess::initDatabase()
+{
+    databaseSetting(strDatabaseName);
+}
+
+bool SRunProcess::isRunning()
+{
+    return m_eRunMode == E_RUN_MODE::MODE_RUN;
+}
+
+void SRunProcess::setList(const QVector<int> &_runList)
+{
+    init();
+    m_eListMode = E_LIST_MODE::MODE_COMPANY;
+    m_vecRunList = _runList;
+}
+
+void SRunProcess::setList(QVector<int> &&_runList)
+{
+    init();
+    m_eListMode = E_LIST_MODE::MODE_COMPANY;
+    m_vecRunList = std::move(_runList);
+}
+
+void SRunProcess::setList(const QVector<SError> &_errorList)
+{
+    init();
+    m_eListMode = E_LIST_MODE::MODE_ERROR;
+    m_vecErrorList = _errorList;
+}
+
+void SRunProcess::setList(QVector<SError> &&_errorList)
+{
+    init();
+    m_eListMode = E_LIST_MODE::MODE_ERROR;
+    m_vecErrorList = std::move(_errorList);
+}
+
+
+void SRunProcess::init()
+{
+    m_vecRunList.clear();
+    m_vecErrorList.clear();
+    m_vecRunOrderList.clear();
+    m_mapEffectRow.clear();
+}
+
+
+void SRunProcess::stop()
+{
+    if (m_pTimer->isActive())
+        m_pTimer->stop();
+    m_bRun = false;
+}
+
+
+template <typename T>
+void SRunProcess::start(QVector<T>&& _list)
+{
+    setList(std::forward<T>(_list));
+    start();
+}
+
+
+void SRunProcess::start()
+{
+    if (!m_pTimer->isActive())
+        m_pTimer->start(ONE_SECOND);
+    m_bRun = true;
+}
+
+
+SReportSummary SRunProcess::getReportSummary()
+{
+    SReportSummary a;
+    return a;
+}
+
+
+QVector<SError> SRunProcess::getErrorList()
+{
+    QVector<SError> hahaha;
+    return hahaha;
+}
+
+
+void SRunProcess::update()
+{
+    switch (m_eListMode)
+    {
+    case E_LIST_MODE::MODE_COMPANY:
+    {
+        updateCompany();
+        break;
+    }
+    case E_LIST_MODE::MODE_ERROR:
+    {
+        updateError();
+        break;
+    }
+    }
+}
+
+
+void SRunProcess::updateCompany()
+{
+    switch(m_eInnerRunMode)
+    {
+    case E_INNER_RUN_MODE::MODE_WAIT:
+    {
+        m_eInnerRunMode = E_INNER_RUN_MODE::MODE_RUN_INIT;
+        break;
+    }
+    case E_INNER_RUN_MODE::MODE_RUN_INIT:
+    {
+        runInitCompany();
+        break;
+    }
+    case E_INNER_RUN_MODE::MODE_RUN_EVENTCODE:
+    {
+        runEventcodeCompany();
+        break;
+    }
+    case E_INNER_RUN_MODE::MODE_WAIT_INIT:
+    case E_INNER_RUN_MODE::MODE_WAIT_EVENTCODE:
+    {
+        break;
+    }
+    }
+}
+
+
+void SRunProcess::updateError()
+{
+    switch(m_eInnerRunMode)
+    {
+    case E_INNER_RUN_MODE::MODE_WAIT:
+    {
+        m_eInnerRunMode = E_INNER_RUN_MODE::MODE_RUN_INIT;
+        break;
+    }
+    case E_INNER_RUN_MODE::MODE_RUN_INIT:
+    {
+        runInitCompany();
+        break;
+    }
+    case E_INNER_RUN_MODE::MODE_RUN_EVENTCODE:
+    {
+        runEventcodeCompany();
+        break;
+    }
+    case E_INNER_RUN_MODE::MODE_WAIT_INIT:
+    case E_INNER_RUN_MODE::MODE_WAIT_EVENTCODE:
+    {
+        break;
+    }
+    }
+}
+
+
+void SRunProcess::setInnerMode(E_INNER_RUN_MODE _inner_mode)
+{
+    m_eInnerRunMode = _inner_mode;
+}
+
+
+void SRunProcess::runInitCompany()
+{
+    setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_INIT);
+
+    QSqlDatabase db = QSqlDatabase::database(strDatabaseName);
+    if (!db.open())
+    {
+        processError(SError(E_ERROR_CODE::DB_OPEN_ERROR));
+        return;
+    }
+    //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 (71, 72, 73)
+    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))
+    {
+        SError err(E_ERROR_CODE::DB_QUERY_ERROR, query.lastQuery() + "\n" + query.lastError().text());
+        processError(std::move(err));
+        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))
+    {
+        SError err(E_ERROR_CODE::DB_QUERY_ERROR, query.lastQuery() + "\n" + query.lastError().text());
+        processError(std::move(err));
+        return;
+    }
+
+    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);
+    }
+
+    setInnerMode(E_INNER_RUN_MODE::MODE_RUN_EVENTCODE);
+    db.close();
+}
+
+
+void SRunProcess::processError(const SError& _error)
+{
+    m_pTimer->stop();
+    m_eInnerRunMode = E_INNER_RUN_MODE::MODE_WAIT;
+    m_eRunMode = E_RUN_MODE::MODE_WAIT;
+    m_errError = _error;
+    emit signalError();
+}
+
+
+void SRunProcess::processError(SError&& _error)
+{
+    m_pTimer->stop();
+    m_eInnerRunMode = E_INNER_RUN_MODE::MODE_WAIT;
+    m_eRunMode = E_RUN_MODE::MODE_WAIT;
+    m_errError = std::move(_error);
+    emit signalError();
+}
+
+
+SError SRunProcess::gerError()
+{
+    return m_errError;
+}
+
+void SRunProcess::userAbort()
+{
+
+}
+
+void SRunProcess::runInitError()
+{
+    setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_INIT);
+
+    for (int i = 0; i < m_vecRunOrderList.size(); ++i)
+    {
+        if (!m_bRun)
+        {
+            userAbort();
+            return;
+        }
+
+        for (auto iterPos = m_mapEffectRow[m_vecRunOrderList.at(i)].cbegin();
+             iterPos != m_mapEffectRow[m_vecRunOrderList.at(i)].cend(); ++iterPos)
+        {
+            if (!m_bRun)
+            {
+                userAbort();
+                return;
+            }
+
+            //execute process;
+
+        }
+
+        emit signalTerminateCompany();
+    }
+
+    setInnerMode(E_INNER_RUN_MODE::MODE_RUN_EVENTCODE);
+}
+
+
+void SRunProcess::runEventcodeCompany()
+{
+    setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_EVENTCODE);
+
+    for (int i = 0; i < m_vecErrorList.size(); ++i)
+    {
+        if (!m_bRun)
+        {
+            userAbort();
+            return;
+        }
+    }
+
+}
+
+
+void SRunProcess::runEventcodeError()
+{
+    setInnerMode(E_INNER_RUN_MODE::MODE_WAIT_EVENTCODE);
+
+
+
+    setInnerMode(E_INNER_RUN_MODE::MODE_RUN_EVENTCODE);
+}
+
+
+SRunProcess::~SRunProcess()
+{
+
+}
+

EffectUI/srunprocess.h

@@ -0,0 +1,97 @@
+#ifndef SRUNPROCESS
+#define SRUNPROCESS
+
+#include <QObject>
+#include <memory>
+#include <QVector>
+#include "sutilclass.h"
+
+class QTimer;
+class QProcess;
+
+//enum class E_RUN_MODE;
+
+
+class SRunProcess:public QObject
+{
+    Q_OBJECT
+    enum class E_LIST_MODE:unsigned short
+    {
+        MODE_COMPANY = 0,
+        MODE_ERROR
+    };
+    enum class E_INNER_RUN_MODE:unsigned short;
+
+
+public:
+    explicit SRunProcess();
+    ~SRunProcess();
+    void setList(const QVector<int>& _runList);
+    void setList(QVector<int>&& _runList);
+    void setList(const QVector<SError>& _errorList);
+    void setList(QVector<SError>&& _errorList);
+    bool isRunning();
+    SRunProcess& operator=(const SRunProcess& other) = delete;
+    SRunProcess(const SRunProcess& other) = delete;
+    template <typename T>
+    void start(QVector<T>&& _list);
+    SError gerError();
+
+public slots:
+    void stop();
+    void start();
+    SReportSummary getReportSummary();
+    QVector<SError> getErrorList();
+
+
+
+private slots:
+    void update();
+
+
+signals:
+    void signalTerminateAllCompany();
+    void signalTerminateCompany();
+    void signalTerminateError();
+    void signalTerminateAllError();
+    void signalUserAbort();
+    void signalError();
+
+
+private:
+    void init();
+    void initDatabase();
+    void run();
+    void updateCompany();
+    void updateError();
+
+    void processError(SError&& _error);
+    void processError(const SError& _error);
+    void runInitCompany();
+    void runInitError();
+    void runEventcodeCompany();
+    void runEventcodeError();
+    void runFinishEventcode();
+
+    void userAbort();
+    void setInnerMode(E_INNER_RUN_MODE _inner_mode);
+
+
+private:
+
+    std::unique_ptr<QTimer> m_pTimer;
+    std::unique_ptr<QProcess> m_pProcess;
+    QVector<int> m_vecRunList;
+    QVector<SError> m_vecErrorList;
+    QVector<int> m_vecRunOrderList;
+    QMap<int, QVector<SEffectRow>> m_mapEffectRow;
+    E_RUN_MODE m_eRunMode;
+    E_LIST_MODE m_eListMode;
+    E_INNER_RUN_MODE m_eInnerRunMode;
+    SError m_errError;
+    bool m_bRun;
+};
+
+
+#endif // SRUNPROCESS
+

EffectUI/sutilclass.cpp

@@ -36,3 +36,24 @@ bool STableWidgetItem::operator <(const QTableWidgetItem &other) const
         return text() < other.text();
     }
 }
+SError::SError(): company_num(-1), platformname_num(-1)
+{
+
+}
+
+
+QString ERROR_MESSAGE[static_cast<int>(E_ERROR_CODE::MAX)] =
+{
+    "DB_OPEN_ERROR",
+    "DB_FULL_ERROR",
+    "DB_LONG_QUERY_ERROR",
+    "DB_QUERY_ERROR",
+    "DB_UNKNOWN_ERROR",
+    "INTERNET_ERROR",
+    "OUT_DATED_CRAWLER",
+    "DELETED_URL_ERROR",
+    "BLOCK_ERROR",
+    "TIMEOUT",
+    "NO_PROGRAM",
+    "UNKNOWN_ERROR",
+};

EffectUI/sutilclass.h

@@ -2,6 +2,9 @@
 #define SUTILCLASS
 
 #include <QTableWidgetItem>
+#include <QDate>
+#include <QString>
+#include <memory>
 
 class STableWidgetItem : public QTableWidgetItem
 {
@@ -13,6 +16,147 @@ public:
     virtual bool operator<(const QTableWidgetItem & other) const override;
 };
 
+enum class E_RUN_MODE:unsigned short
+{
+    MODE_WAIT = 0,
+    MODE_TERMINATING,
+    MODE_RUN
+};
+
+
+enum class E_CRAWL_STATE:unsigned short
+{
+    OK = 0,
+    FAIL,
+    NO
+};
+
+enum class E_ERROR_CODE:unsigned short
+{
+    DB_OPEN_ERROR = 0,
+    DB_FULL_ERROR,
+    DB_LONG_QUERY_ERROR,
+    DB_QUERY_ERROR,
+    DB_UNKNOWN_ERROR,
+    INTERNET_ERROR,
+    OUT_DATED_CRAWLER,
+    DELETED_URL_ERROR,
+    BLOCK_ERROR,
+    TIMEOUT,
+    NO_PROGRAM,
+    UNKNOWN_ERROR,
+    MAX
+};
+
+
+struct SReport
+{
+    E_CRAWL_STATE state;
+    unsigned int company_num;
+    unsigned int platformname_num;
+    QString event_code;
+    QString url;
+};
+
+struct SReportSummary
+{
+    unsigned int nOk;
+    unsigned int nError;
+    unsigned int nNo;
+    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) {}
+};
+
+
+struct SError
+{
+    E_CRAWL_STATE state;
+    unsigned int company_num;
+    unsigned int platformname_num;
+    QString event_code;
+    QString url;
+    E_ERROR_CODE error_code;
+    QString str_error;
+    SError();
+
+    SError(E_ERROR_CODE _error_code): 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),
+        error_code(_error_code), str_error(std::forward<T>(_str_error))
+    {
+
+    }
+    template <typename A, typename B, typename C>
+    SError(E_CRAWL_STATE _state, unsigned int _company_num, unsigned int _platformname_num,
+           A&& _event_code, B&& _url, E_ERROR_CODE _error_code, C&& _str_error):
+        state(_state), company_num(_company_num), platformname_num(_platformname_num),
+        event_code(std::forward<A>(_event_code)), url(std::forward<B>(_url)), error_code(_error_code),
+        str_error(std::forward<C>(_str_error))
+    {
+
+    }
+};
+
+struct SEffectRow
+{
+    int company_num;
+    QString company_name;
+    QDate company_startdate;
+    QDate company_enddate;
+    int event_num;
+    QDate event_date;
+    QString url;
+    QString eventcode;
+    int platformname_num;
+    SEffectRow():company_num(-1), event_num(-1), platformname_num(-1){}
+    template <typename A, typename B, typename C, typename D, typename E, typename F>
+    SEffectRow(int _company_num, A&& _company_name, B&& _company_startdate, C&& _company_enddate, int _event_num,
+               D&& _event_date, E&& _url, F&& _eventcode, int _platformname_num):
+        company_num(_company_num), company_name(std::forward<A>(_company_name)), company_startdate(std::forward<B>(_company_startdate)),
+        company_enddate(std::forward<C>(_company_enddate)), event_num(_event_num), event_date(std::forward<D>(_event_date)),
+        url(std::forward<E>(_url)), eventcode(std::forward<F>(_eventcode)), platformname_num(_platformname_num)
+    {
+
+    }
+
+};
+
+enum class E_PLATFORM
+{
+    NAVER_BLOG = 0,
+    NAVER_CAFE,
+    NAVER_NEWS,
+    DAUM_CAFE,
+    DAUM_BLOG,
+    DAUM_NEWS,
+    INSTAGRAM,
+    KAKAOSTORY,
+    FACEBOOK
+};
+
+enum class E_INFO
+{
+    OK = 0,
+    ERROR,
+    NO,
+    TOTAL
+};
+
+enum E_LOG_COLUMN
+{
+    STATUS = 0,
+    EVENT_CODE,
+    URL,
+    ERROR_CODE,
+    ERROR_MSG
+};
+
 
 #endif // SUTILCLASS
 

EffectUI/sutilfunction.cpp

@@ -4,6 +4,10 @@
 #include <QSettings>
 #include <QSqlDatabase>
 #include <QMessageBox>
+#include <QRegExp>
+
+extern QString ERROR_MESSAGE[];
+
 void databaseSetting(const QString &str)
 {
     QSettings settings("effect.ini");
@@ -28,3 +32,29 @@ void messageBoxError(const QString &title, const QString &body)
     QMessageBox messagebox(QMessageBox::Critical, title, body);
     messagebox.exec();
 }
+
+QString errorCodeToString(E_ERROR_CODE _error_code)
+{
+    if (0 <= static_cast<int>(_error_code) &&
+            static_cast<int>(_error_code) < static_cast<int>(E_ERROR_CODE::MAX))
+        return ERROR_MESSAGE[static_cast<int>(_error_code)];
+    else
+        return ERROR_MESSAGE[static_cast<int>(E_ERROR_CODE::UNKNOWN_ERROR)];
+}
+
+E_ERROR_CODE strErrorCodeToEnumErrorCode(const QString& _str)
+{
+    static QRegExp re("^[\\D]");
+    QString str = _str.trimmed().replace(re, "");
+    bool ok = false;
+    int n = str.toInt(&ok);
+
+    if (ok && (0 <= n && n < static_cast<int>(E_ERROR_CODE::MAX)))
+    {
+        return static_cast<E_ERROR_CODE>(n);
+    }
+    else
+    {
+        return E_ERROR_CODE::UNKNOWN_ERROR;
+    }
+}

EffectUI/sutilfunction.h

@@ -1,9 +1,12 @@
 #ifndef SUTILFUNCTION
 #define SUTILFUNCTION
-
+#include "sutilclass.h"
 class QString;
 
 void databaseSetting(const QString& str);
 void messageBoxError(const QString& title, const QString &body);
+QString errorCodeToString(E_ERROR_CODE _error_code);
+E_ERROR_CODE strErrorCodeToEnumErrorCode(const QString& _str);
+
 #endif // SUTILFUNCTION
 

EffectUI/widget.cpp

@@ -19,6 +19,15 @@ Widget::Widget(QWidget *parent) :
     mainLayout->addWidget(e);
 
     mainLayout->addWidget(d);
+
+    connect(e, &SAddDelWidget::signalClickedAddBtn, [&c, &d](){
+        d->addList(c->getSelectedList());
+    });
+
+    connect(e, &SAddDelWidget::signalClickedDelBtn, [&c, &d](){
+        d->removeSelectedList();
+    });
+
     setLayout(mainLayout);
 
     show();