From ffbaf3084f60201757f2c2417ff261fbe07709f8 Mon Sep 17 00:00:00 2001 From: admin Date: Thu, 20 Oct 2016 04:14:57 +0000 Subject: [PATCH] =?UTF-8?q?logwidget=20=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@301 8346c931-da38-4b9b-9d4c-e48b93cbd075 --- EffectUI/EffectUI.pro | 12 +- EffectUI/EffectUI.pro.user | 2 +- EffectUI/scompanyprocess.cpp | 220 ++++++++++++++++++++++++++++++++ EffectUI/scompanyprocess.h | 40 ++++++ EffectUI/serrorprocess.cpp | 90 +++++++++++++ EffectUI/serrorprocess.h | 38 ++++++ EffectUI/slogwidget.cpp | 53 ++++++++ EffectUI/slogwidget.h | 27 ++++ EffectUI/sparentprocess.cpp | 137 +++++--------------- EffectUI/sparentprocess.h | 48 +++++-- EffectUI/srunninglistwidget.cpp | 8 +- EffectUI/srunninglistwidget.h | 2 +- EffectUI/srunningprocess.cpp | 153 ++++++++++++++++++++++ EffectUI/srunningprocess.h | 68 ++++++++++ EffectUI/sutilclass.h | 18 ++- EffectUI/widget.cpp | 4 + 16 files changed, 790 insertions(+), 130 deletions(-) create mode 100644 EffectUI/scompanyprocess.cpp create mode 100644 EffectUI/scompanyprocess.h create mode 100644 EffectUI/serrorprocess.cpp create mode 100644 EffectUI/serrorprocess.h create mode 100644 EffectUI/slogwidget.cpp create mode 100644 EffectUI/slogwidget.h create mode 100644 EffectUI/srunningprocess.cpp create mode 100644 EffectUI/srunningprocess.h diff --git a/EffectUI/EffectUI.pro b/EffectUI/EffectUI.pro index 96928ec..c81ba27 100644 --- a/EffectUI/EffectUI.pro +++ b/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 diff --git a/EffectUI/EffectUI.pro.user b/EffectUI/EffectUI.pro.user index 41b90fd..17a1727 100644 --- a/EffectUI/EffectUI.pro.user +++ b/EffectUI/EffectUI.pro.user @@ -1,6 +1,6 @@ - + EnvironmentId diff --git a/EffectUI/scompanyprocess.cpp b/EffectUI/scompanyprocess.cpp new file mode 100644 index 0000000..37e548e --- /dev/null +++ b/EffectUI/scompanyprocess.cpp @@ -0,0 +1,220 @@ +#include "scompanyprocess.h" +#include "sutilfunction.h" +#include +#include +#include +#include +#include +#include + + +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& _list) +{ + m_vecRunList = _list; +} + +void SCompanyProcess::setList(QVector&& _list) +{ + m_vecRunList = std::move(_list); +} + +void SCompanyProcess::setList(const QVector& _list) +{ + +} + +void SCompanyProcess::setList(QVector&& _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()); + } +*/ + 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); + } + + 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); +} + diff --git a/EffectUI/scompanyprocess.h b/EffectUI/scompanyprocess.h new file mode 100644 index 0000000..122be5c --- /dev/null +++ b/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& _list) override; + virtual void setList(QVector&& _list) override; + virtual void setList(const QVector& _list) override; + virtual void setList(QVector&& _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 m_vecRunList; + QVector m_vecRunOrderList; + QMap> m_mapEffectRow; + QVector::iterator m_iterRunOrderList; + QVector::iterator m_iterEffectRow; + bool m_bDoneCompany; +}; + +#endif // SCOMPANYPROCESS + diff --git a/EffectUI/serrorprocess.cpp b/EffectUI/serrorprocess.cpp new file mode 100644 index 0000000..0047e38 --- /dev/null +++ b/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& _list) +{ + +} + +void SErrorProcess::setList(QVector&& _list) +{ + +} + +void SErrorProcess::setList(const QVector& _list) +{ + m_vecRunList = _list; +} + +void SErrorProcess::setList(QVector&& _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(); +} + + + diff --git a/EffectUI/serrorprocess.h b/EffectUI/serrorprocess.h new file mode 100644 index 0000000..f0d05d8 --- /dev/null +++ b/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& _list) override; + virtual void setList(QVector&& _list) override; + virtual void setList(const QVector& _list) override; + virtual void setList(QVector&& _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 m_vecRunList; + QVector::iterator m_iterEffectRow; +}; + + +#endif // SERRORPROCESS + diff --git a/EffectUI/slogwidget.cpp b/EffectUI/slogwidget.cpp new file mode 100644 index 0000000..486fada --- /dev/null +++ b/EffectUI/slogwidget.cpp @@ -0,0 +1,53 @@ +#include "slogwidget.h" +#include +#include +#include +#include +#include +#include +#include + +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); +} + + + diff --git a/EffectUI/slogwidget.h b/EffectUI/slogwidget.h new file mode 100644 index 0000000..c99b11a --- /dev/null +++ b/EffectUI/slogwidget.h @@ -0,0 +1,27 @@ +#ifndef SLOGWIDGET +#define SLOGWIDGET + +#include + +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 + diff --git a/EffectUI/sparentprocess.cpp b/EffectUI/sparentprocess.cpp index 9faf16d..4286a6c 100644 --- a/EffectUI/sparentprocess.cpp +++ b/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 SParentProcess::getErrorList() const +QVector 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); } -*/ diff --git a/EffectUI/sparentprocess.h b/EffectUI/sparentprocess.h index cabfad8..9debb85 100644 --- a/EffectUI/sparentprocess.h +++ b/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& _list) = 0; virtual void setList(QVector&& _list) = 0; - 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; + QVector getErrorList() const; SReportSummary getReportSummary(int _id) const; QMap 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 m_vecError; + QVector m_vecError; bool m_bRunning; unsigned int nTime; SError m_error; diff --git a/EffectUI/srunninglistwidget.cpp b/EffectUI/srunninglistwidget.cpp index 45427ce..eb92e97 100644 --- a/EffectUI/srunninglistwidget.cpp +++ b/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(E_INFO::NO)) + "/" + + slInfo.at(static_cast(E_INFO::ACTIVE_EVENT)) + "/" + + slInfo.at(static_cast(E_INFO::ALL_ACTIVE_GROUP)) + "/" + slInfo.at(static_cast(E_INFO::TOTAL))); } } diff --git a/EffectUI/srunninglistwidget.h b/EffectUI/srunninglistwidget.h index 63fcbdf..fad54fa 100644 --- a/EffectUI/srunninglistwidget.h +++ b/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(); diff --git a/EffectUI/srunningprocess.cpp b/EffectUI/srunningprocess.cpp new file mode 100644 index 0000000..ffa1969 --- /dev/null +++ b/EffectUI/srunningprocess.cpp @@ -0,0 +1,153 @@ +#include "srunningprocess.h" +#include + +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& _list) +{ + if (!isRunning()) + { + m_pCurrentProcess = m_pErrorProcess; + m_pCurrentProcess->setList(_list); + } +} + +void SRunningProcess::setList(QVector&& _list) +{ + if (!isRunning()) + { + m_pCurrentProcess = m_pErrorProcess; + m_pCurrentProcess->setList(std::move(_list)); + } +} + +void SRunningProcess::setList(const QVector& _list) +{ + if (!isRunning()) + { + m_pCurrentProcess = m_pCompanyProcess; + m_pCurrentProcess->setList(_list); + } +} + +void SRunningProcess::setList(QVector&& _list) +{ + if (!isRunning()) + { + m_pCurrentProcess = m_pCompanyProcess; + m_pCurrentProcess->setList(std::move(_list)); + } +} + + +template +void SRunningProcess::start(QVector&& _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 errors = m_pCurrentProcess->getErrorList(); + QMap 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); +} + diff --git a/EffectUI/srunningprocess.h b/EffectUI/srunningprocess.h new file mode 100644 index 0000000..b615ba9 --- /dev/null +++ b/EffectUI/srunningprocess.h @@ -0,0 +1,68 @@ +#ifndef SRUNNINGPROCESS +#define SRUNNINGPROCESS +#include +#include +#include +#include "sutilclass.h" +#include +#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& _list); + void setList(QVector&& _list); + void setList(const QVector& _list); + void setList(QVector&& _list); + template + void start(QVector&& _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& _error, + const QMap& _report); + void signalTerminateError(const SError& _error); + void signalCompanyComplete(int _num, const SReportSummary& summary); + void signalSuccessErrorCompany(int _num); + +private: + std::unique_ptr m_pTimer; + std::shared_ptr m_pErrorProcess; + std::shared_ptr m_pCompanyProcess; + E_PROCESS_MODE m_eMode; + + std::shared_ptr m_pCurrentProcess; +}; + +#endif // SRUNNINGPROCESS + diff --git a/EffectUI/sutilclass.h b/EffectUI/sutilclass.h index fce303f..6bdeac3 100644 --- a/EffectUI/sutilclass.h +++ b/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 - 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(_str_error)) { @@ -144,7 +147,8 @@ enum class E_INFO { OK = 0, ERROR, - NO, + ACTIVE_EVENT, + ALL_ACTIVE_GROUP, TOTAL }; diff --git a/EffectUI/widget.cpp b/EffectUI/widget.cpp index ea0c63b..c60a76c 100644 --- a/EffectUI/widget.cpp +++ b/EffectUI/widget.cpp @@ -3,6 +3,7 @@ #include "scompanylistwidget.h" #include "srunninglistwidget.h" #include "sadddelwidget.h" +#include "slogwidget.h" #include 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();