From 199b9ca2b33f04b928fff24498e0f503f48f9fda Mon Sep 17 00:00:00 2001 From: admin Date: Mon, 17 Oct 2016 10:06:16 +0000 Subject: [PATCH] =?UTF-8?q?sparentprocess=20=ED=81=B4=EB=9E=98=EC=8A=A4=20?= =?UTF-8?q?=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit git-svn-id: svn://192.168.0.12/source@300 8346c931-da38-4b9b-9d4c-e48b93cbd075 --- EffectUI/EffectUI.pro | 8 +- EffectUI/EffectUI.pro.user | 21 +- EffectUI/scompanylistwidget.cpp | 24 +- EffectUI/scompanylistwidget.h | 1 + EffectUI/sparentprocess.cpp | 429 ++++++++++++++++++++++++++++++++ EffectUI/sparentprocess.h | 76 ++++++ EffectUI/srunninglistwidget.cpp | 62 ++++- EffectUI/srunninglistwidget.h | 14 +- EffectUI/srunprocess.cpp | 379 ++++++++++++++++++++++++++++ EffectUI/srunprocess.h | 97 ++++++++ EffectUI/sutilclass.cpp | 21 ++ EffectUI/sutilclass.h | 144 +++++++++++ EffectUI/sutilfunction.cpp | 30 +++ EffectUI/sutilfunction.h | 5 +- EffectUI/widget.cpp | 9 + 15 files changed, 1291 insertions(+), 29 deletions(-) create mode 100644 EffectUI/sparentprocess.cpp create mode 100644 EffectUI/sparentprocess.h create mode 100644 EffectUI/srunprocess.cpp create mode 100644 EffectUI/srunprocess.h diff --git a/EffectUI/EffectUI.pro b/EffectUI/EffectUI.pro index 75807b6..96928ec 100644 --- a/EffectUI/EffectUI.pro +++ b/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 diff --git a/EffectUI/EffectUI.pro.user b/EffectUI/EffectUI.pro.user index 0084adb..41b90fd 100644 --- a/EffectUI/EffectUI.pro.user +++ b/EffectUI/EffectUI.pro.user @@ -1,6 +1,6 @@ - + EnvironmentId @@ -8,7 +8,7 @@ ProjectExplorer.Project.ActiveTarget - 0 + 3 ProjectExplorer.Project.EditorSettings @@ -620,7 +620,7 @@ Desktop Qt 5.4.0 MSVC2013 64bit Desktop Qt 5.4.0 MSVC2013 64bit {4a73e1a8-867f-4a8f-a70a-a3bb186185e4} - 0 + 1 0 0 @@ -781,15 +781,16 @@ 13 14 - -1 + 2 - - - false - %{buildDir} - Custom Executable + EffectUI - ProjectExplorer.CustomExecutableRunConfiguration + Qt4ProjectManager.Qt4RunConfiguration:C:/source/EffectUI/EffectUI.pro + + EffectUI.pro + false + false + 3768 false true diff --git a/EffectUI/scompanylistwidget.cpp b/EffectUI/scompanylistwidget.cpp index 8edbb14..916e382 100644 --- a/EffectUI/scompanylistwidget.cpp +++ b/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; @@ -298,12 +307,15 @@ QVector> SCompanyListWidget::getSelectedList() const foreach (auto& modelIndex, modelIndexes) { - QVector item; - item.append(QTableWidgetItem(*m_ptableWidget->item(modelIndex.row(), static_cast(E_TABLE_HEADER::COMPANY)))); - item.append(QTableWidgetItem(*m_ptableWidget->item(modelIndex.row(), static_cast(E_TABLE_HEADER::START_DATE)))); - item.append(QTableWidgetItem(*m_ptableWidget->item(modelIndex.row(), static_cast(E_TABLE_HEADER::END_DATE)))); - item.append(STableWidgetItem(*m_ptableWidget->item(modelIndex.row(), static_cast(E_TABLE_HEADER::EVENT_NUM)))); - items.append(item); + if (!m_ptableWidget->isRowHidden(modelIndex.row())) + { + QVector item; + item.append(QTableWidgetItem(*m_ptableWidget->item(modelIndex.row(), static_cast(E_TABLE_HEADER::COMPANY)))); + item.append(QTableWidgetItem(*m_ptableWidget->item(modelIndex.row(), static_cast(E_TABLE_HEADER::START_DATE)))); + item.append(QTableWidgetItem(*m_ptableWidget->item(modelIndex.row(), static_cast(E_TABLE_HEADER::END_DATE)))); + item.append(STableWidgetItem(*m_ptableWidget->item(modelIndex.row(), static_cast(E_TABLE_HEADER::EVENT_NUM)))); + items.append(item); + } } return items; } diff --git a/EffectUI/scompanylistwidget.h b/EffectUI/scompanylistwidget.h index b4508d6..cebf433 100644 --- a/EffectUI/scompanylistwidget.h +++ b/EffectUI/scompanylistwidget.h @@ -34,6 +34,7 @@ public slots: void refresh(); void search(); void slotClickedItem(); + void enableTableWidget(bool _enable); signals: void signalClickedItem(); diff --git a/EffectUI/sparentprocess.cpp b/EffectUI/sparentprocess.cpp new file mode 100644 index 0000000..9faf16d --- /dev/null +++ b/EffectUI/sparentprocess.cpp @@ -0,0 +1,429 @@ +#include "sparentprocess.h" +#include "sutilfunction.h" +#include +#include + +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 SParentProcess::getErrorList() const +{ + return m_vecError; +} + +SReportSummary SParentProcess::getReportSummary(int _id) const +{ + return m_mapReportSummary[_id]; +} + +QMap 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(E_LOG_COLUMN::EVENT_CODE)); + errorResult.url = slLog.at(static_cast(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(E_LOG_COLUMN::EVENT_CODE)); + errorResult.url = slLog.at(static_cast(E_LOG_COLUMN::URL)); + */ + + switch (slLog.size()) + { + case static_cast(E_LOG_COLUMN::ERROR_MSG) + 1: + { + errorResult.str_error = slLog.at( + static_cast(E_LOG_COLUMN::ERROR_MSG)).trimmed(); + } + case static_cast(E_LOG_COLUMN::ERROR_CODE) + 1: + { + errorResult.error_code = strErrorCodeToEnumErrorCode( + slLog.at(static_cast(E_LOG_COLUMN::ERROR_CODE)).trimmed()); + } + case static_cast(E_LOG_COLUMN::URL) + 1: + { + errorResult.event_code = slLog.at( + static_cast(E_LOG_COLUMN::EVENT_CODE)).trimmed(); + errorResult.url = slLog.at( + static_cast(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; +} +*/ diff --git a/EffectUI/sparentprocess.h b/EffectUI/sparentprocess.h new file mode 100644 index 0000000..cabfad8 --- /dev/null +++ b/EffectUI/sparentprocess.h @@ -0,0 +1,76 @@ +#ifndef SPARENTPROCESS +#define SPARENTPROCESS +#include +#include "sutilclass.h" +#include +#include +#include + +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& _list) = 0; + virtual void setList(QVector&& _list) = 0; + virtual void setList(const QVector& _list) = 0; + virtual void setList(QVector&& _list) = 0; + virtual void runInit() = 0; + virtual void runEventCode() = 0; + virtual void clear(); + QVector getErrorList() const; + SReportSummary getReportSummary(int _id) const; + QMap 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 m_vecError; + bool m_bRunning; + unsigned int nTime; + SError m_error; + bool m_bUserAbort; + QMap m_mapReportSummary; +}; + + +#endif // SPARENTPROCESS + diff --git a/EffectUI/srunninglistwidget.cpp b/EffectUI/srunninglistwidget.cpp index 010d450..45427ce 100644 --- a/EffectUI/srunninglistwidget.cpp +++ b/EffectUI/srunninglistwidget.cpp @@ -14,10 +14,12 @@ #include #include +/* 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> items) m_ptableWidget->setItem(m_ptableWidget->rowCount() - 1, static_cast(E_TABLE_HEADER::STATUS), new QTableWidgetItem("")); + m_ptableWidget->setItem(m_ptableWidget->rowCount() - 1, + static_cast(E_TABLE_HEADER::INFOMATION), + new QTableWidgetItem("")); m_ptableWidget->setItem(m_ptableWidget->rowCount() - 1, static_cast(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(E_INFO::TOTAL)) + return; + int nOk = slInfo.at(static_cast(E_INFO::OK)).toInt(); + int nError = slInfo.at(static_cast(E_INFO::ERROR)).toInt(); + + ++nOk; + --nError; + + item->setText(QString::number(nOk) + "/" + + QString::number(nError) + "/" + + slInfo.at(static_cast(E_INFO::NO)) + "/" + + slInfo.at(static_cast(E_INFO::TOTAL))); + } +} + + + void SRunningListWidget::slotTimerStart() { qDebug() << "clicked TimerStart()"; diff --git a/EffectUI/srunninglistwidget.h b/EffectUI/srunninglistwidget.h index 7775f64..63fcbdf 100644 --- a/EffectUI/srunninglistwidget.h +++ b/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> items); QVector getSelectedList() const; QVector getAllList() const; - void enableBtnTimerStart(bool enable); - void enableBtnTimerStop(bool enable); - void enableBtnForceStart(bool enable); - void enableBtnForceStop(bool enable); + void enableBtnTimerStart(bool _enable); + void enableBtnTimerStop(bool _enable); + void enableBtnForceStart(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(); diff --git a/EffectUI/srunprocess.cpp b/EffectUI/srunprocess.cpp new file mode 100644 index 0000000..7521347 --- /dev/null +++ b/EffectUI/srunprocess.cpp @@ -0,0 +1,379 @@ +#include "srunprocess.h" +#include "sutilclass.h" +#include "sutilfunction.h" +#include +#include +#include +#include +#include +#include + + +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 &_runList) +{ + init(); + m_eListMode = E_LIST_MODE::MODE_COMPANY; + m_vecRunList = _runList; +} + +void SRunProcess::setList(QVector &&_runList) +{ + init(); + m_eListMode = E_LIST_MODE::MODE_COMPANY; + m_vecRunList = std::move(_runList); +} + +void SRunProcess::setList(const QVector &_errorList) +{ + init(); + m_eListMode = E_LIST_MODE::MODE_ERROR; + m_vecErrorList = _errorList; +} + +void SRunProcess::setList(QVector &&_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 +void SRunProcess::start(QVector&& _list) +{ + setList(std::forward(_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 SRunProcess::getErrorList() +{ + QVector 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 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() +{ + +} + diff --git a/EffectUI/srunprocess.h b/EffectUI/srunprocess.h new file mode 100644 index 0000000..8c97439 --- /dev/null +++ b/EffectUI/srunprocess.h @@ -0,0 +1,97 @@ +#ifndef SRUNPROCESS +#define SRUNPROCESS + +#include +#include +#include +#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& _runList); + void setList(QVector&& _runList); + void setList(const QVector& _errorList); + void setList(QVector&& _errorList); + bool isRunning(); + SRunProcess& operator=(const SRunProcess& other) = delete; + SRunProcess(const SRunProcess& other) = delete; + template + void start(QVector&& _list); + SError gerError(); + +public slots: + void stop(); + void start(); + SReportSummary getReportSummary(); + QVector 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 m_pTimer; + std::unique_ptr m_pProcess; + QVector m_vecRunList; + QVector m_vecErrorList; + QVector m_vecRunOrderList; + QMap> 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 + diff --git a/EffectUI/sutilclass.cpp b/EffectUI/sutilclass.cpp index c0d3790..83c2c18 100644 --- a/EffectUI/sutilclass.cpp +++ b/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(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", +}; diff --git a/EffectUI/sutilclass.h b/EffectUI/sutilclass.h index 939e783..fce303f 100644 --- a/EffectUI/sutilclass.h +++ b/EffectUI/sutilclass.h @@ -2,6 +2,9 @@ #define SUTILCLASS #include +#include +#include +#include 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 + SError(E_ERROR_CODE _error_code, T&& _str_error): company_num(-1), platformname_num(-1), + error_code(_error_code), str_error(std::forward(_str_error)) + { + + } + template + 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(_event_code)), url(std::forward(_url)), error_code(_error_code), + str_error(std::forward(_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 + 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(_company_name)), company_startdate(std::forward(_company_startdate)), + company_enddate(std::forward(_company_enddate)), event_num(_event_num), event_date(std::forward(_event_date)), + url(std::forward(_url)), eventcode(std::forward(_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 diff --git a/EffectUI/sutilfunction.cpp b/EffectUI/sutilfunction.cpp index d0c5db1..d91646a 100644 --- a/EffectUI/sutilfunction.cpp +++ b/EffectUI/sutilfunction.cpp @@ -4,6 +4,10 @@ #include #include #include +#include + +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(_error_code) && + static_cast(_error_code) < static_cast(E_ERROR_CODE::MAX)) + return ERROR_MESSAGE[static_cast(_error_code)]; + else + return ERROR_MESSAGE[static_cast(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(E_ERROR_CODE::MAX))) + { + return static_cast(n); + } + else + { + return E_ERROR_CODE::UNKNOWN_ERROR; + } +} diff --git a/EffectUI/sutilfunction.h b/EffectUI/sutilfunction.h index e90a770..186e5c4 100644 --- a/EffectUI/sutilfunction.h +++ b/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 diff --git a/EffectUI/widget.cpp b/EffectUI/widget.cpp index be38369..ea0c63b 100644 --- a/EffectUI/widget.cpp +++ b/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();