etc/clients
1
0
Fork 0
Code Issues Pull Requests Releases Activity

sparentprocess 클래스 추가

Browse Source 
git-svn-id: svn://192.168.0.12/source@300 8346c931-da38-4b9b-9d4c-e48b93cbd075
This commit is contained in:
admin
2016-10-17 10:06:16 +00:00
parent bdd6780920
commit 199b9ca2b3
15 changed files with 1291 additions and 29 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
EffectUI/EffectUI.pro
View File

@@ -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

21
EffectUI/EffectUI.pro.user
View File

@@ -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.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.DefaultDisplayName">EffectUI</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>

12
EffectUI/scompanylistwidget.cpp
View File

@@ -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;
}

1
EffectUI/scompanylistwidget.h
View File

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

429
EffectUI/sparentprocess.cpp Normal file
View File

@@ -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;
}
*/

76
EffectUI/sparentprocess.h Normal file
View File

@@ -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

62
EffectUI/srunninglistwidget.cpp
View File

@@ -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()";

14
EffectUI/srunninglistwidget.h
View File

@@ -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 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();

379
EffectUI/srunprocess.cpp Normal file
View File

@@ -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()
{
}

97
EffectUI/srunprocess.h Normal file
View File

@@ -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

21
EffectUI/sutilclass.cpp
View File

@@ -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",
};

144
EffectUI/sutilclass.h
View File

@@ -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

30
EffectUI/sutilfunction.cpp
View File

@@ -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;
}
}

5
EffectUI/sutilfunction.h
View File

@@ -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

9
EffectUI/widget.cpp
View File

@@ -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();