프로젝트 이름 변경

FilterProcess -> Legacy_FilterProcess로 변경
sfilterprocess -> FilterProcess로 변경


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

FilterProcess/FilterProcess.pro

@@ -1,9 +1,10 @@
 #-------------------------------------------------
 #
-# Project created by QtCreator 2015-04-30T16:26:12
+# Project created by QtCreator 2016-02-29T16:47:52
 #
 #-------------------------------------------------
-QT      += widgets sql
+
+QT       += widgets sql network
 
 TARGET = FilterProcess
 CONFIG   += console
@@ -11,10 +12,31 @@ CONFIG   -= app_bundle
 
 TEMPLATE = app
 
-SOURCES += main.cpp \
-    sfilterprocess.cpp \
-    ../Json/sjson.cpp
 
-HEADERS +=     sfilterprocess.h\
+SOURCES += main.cpp \
+    sdbmanager.cpp \
+    sinitializer.cpp \
+    sfilterprocess.cpp \
+    sfilteralgorithm.cpp \
+    ../Json/sjson.cpp \
+    sdatagroup.cpp \
+    sconsumer.cpp \
+    sinfluencer.cpp \
+    sspammer.cpp \
+    spowercafe.cpp \
+    shttpsender.cpp
+
+HEADERS += \
+    sdbmanager.h \
+    sinitializer.h \
+    sfilterprocess.h \
+    sfilteralgorithm.h \
+    ../common.h \
     ../Json/sjson.h \
-    ../common.h
+    sdatagroup.h \
+    sservice.h \
+    sinfluencer.h \
+    sconsumer.h \
+    sspammer.h \
+    spowercafe.h \
+    shttpsender.h

FilterProcess/main.cpp

@@ -1,25 +1,42 @@
+#include <iostream>
 #include "sfilterprocess.h"
 #include <QCoreApplication>
+#include <QLocale>
+#include <QDate>
+#include "shttpsender.h"
+using namespace std;
 int main(int argc, char *argv[])
-{    
+{
-    QCoreApplication a(argc,argv);
+    QCoreApplication a(argc, argv);
     cout << "build date : ";
     cout << QLocale("en_US").toDate(QString(__DATE__).simplified(), "MMM d yyyy").toString("yyyy-MM-dd").toStdString();
     cout << " ";
     cout << QString(__TIME__).toStdString() << endl;
+    SFilterProcess filter;
+
     if (argc != 3)
     {
-        cout << "Error : Argument " << endl;
+        cout << "check argument " << endl;
-        return 0;
+        return -1;
     }
-    {
 
+    a.processEvents();
+
+    if (!filter.init(argv[1], argv[2]))
+    //if (!filter.init(QString::number(370), "Check"))
+    {
+        cout << "filter init error" << endl;
+        exit(1);
     }
-    SFilterProcess *process = new SFilterProcess;    
+
-    if (process->ReloadSetup())
+    if (!filter.run())
-        process->run(argv[1],argv[2]);
+    {
-    else
+        cout << "filter run error" << endl;
-        cout << "Error : Setup.ini not read" << endl;
+        exit(1);
-    delete process;
+    }
-    return 0;
+
+    SHttpSender httpSender;
+    httpSender.SendData(filter.getCompanyNum());
+
+    return a.exec();
 }

FilterProcess/sconsumer.cpp

@@ -0,0 +1,969 @@
+#include "sconsumer.h"
+#include <QSqlQuery>
+#include <QSqlDatabase>
+#include <QSqlError>
+#include <QDebug>
+#include <QDateTime>
+#include <QDate>
+#include <QJsonArray>
+#include <QJsonObject>
+#include <QJsonDocument>
+#include <QJsonValue>
+
+bool SConsumer::uploadData(int _companyNum)
+{
+
+    QSqlDatabase dbWeb = m_pSInitializer->getDatabase(SDBManager::E_DATABASE_WEB);
+    m_pSInitializer->insertLog("Start Consumer upload");
+    m_pSInitializer->updateWebDBInfoState(dbWeb, _companyNum, "Consumer (Start)");
+    if (!m_SBodyConsumerMap.uploadData(dbWeb, _companyNum))
+    {
+        m_pSInitializer->insertLog("Fail to upload body_consumer_map");
+        return false;
+    }
+    /*
+    if (!m_SStatsConUserBuzzybyday.uploadData(dbWeb, _companyNum))
+    {
+        m_pSInitializer->insertLog("Fail to upload stats_con_user_buzzbyday");
+        return false;
+    }
+    */
+    if (!m_SStatsJson.uploadData(dbWeb, _companyNum))
+    {
+        m_pSInitializer->insertLog("Fail to upload stats_json");
+        return false;
+    }
+
+
+    m_pSInitializer->insertLog("End Consumer upload");
+    m_pSInitializer->updateWebDBInfoState(dbWeb, _companyNum, "Consumer (Finish)");
+    return true;
+}
+
+bool SConsumer::makeCategory(SDatagroup &_datagroup, int _nCategory, const QList<SInitializer::stFilter> &_listFilter)
+{
+    QVector<QStringList> vecData[SInitializer::E_ARTICLE_MAX];
+    bool bFiltered[SInitializer::E_ARTICLE_MAX];
+
+    for (int i = 0; i < SInitializer::E_ARTICLE_MAX; i++)
+        bFiltered[i] = false;
+    _datagroup.copyData(vecData);
+    foreach (const SInitializer::stFilter& filter, _listFilter)
+    {
+        switch(filter.m_nType)
+        {
+        case E_FILTER_TYPE_DATE://Date
+            m_SFilterAlgorithm.FilterDate(vecData, bFiltered, filter.m_vData.toString(),
+                                          m_pSInitializer->getColumnIntArray()[SInitializer::E_DATA_article_date]);
+
+            break;
+        case E_FILTER_TYPE_SEARCH:
+            m_SFilterAlgorithm.FilterSearch(vecData, bFiltered, filter.m_vData.toString());
+
+            break;
+        case E_FILTER_TYPE_LENGTH:
+            m_SFilterAlgorithm.FilterLength(vecData, bFiltered, filter.m_vData.toString());
+            break;
+        case E_FILTER_TYPE_REPLACE:
+            m_SFilterAlgorithm.FilterReplace(vecData, bFiltered, filter.m_vData.toString());
+            break;
+        case E_FILTER_TYPE_COUNTER:
+            m_SFilterAlgorithm.FilterCounter(vecData, bFiltered, filter.m_vData.toString());
+            break;
+        }
+    }
+    stReal streal;
+    m_pSInitializer->insertLog(QString("CategoryNum:") + QString::number(_nCategory) + ",(" +
+                               QString::number(vecData[SInitializer::E_ARTICLE_BODY].size()) + '/' + QString::number(vecData[SInitializer::E_ARTICLE_REPLY].size()) + ")" + "(Body/Reply)" );
+    const int *anColumn = m_pSInitializer->getColumnIntArray();
+    if (bFiltered[SInitializer::E_ARTICLE_BODY])
+    {
+        foreach (const QStringList& strlist, vecData[SInitializer::E_ARTICLE_BODY])
+        {
+            streal.m_setRealAllUrl.insert(strlist[anColumn[SInitializer::E_DATA_article_url]].trimmed());
+            streal.m_setRealBodyUrl.insert(strlist[anColumn[SInitializer::E_DATA_article_url]].trimmed());
+            _datagroup.addRealUrl(strlist[anColumn[SInitializer::E_DATA_article_url]].trimmed());
+        }
+    }
+
+    if (bFiltered[SInitializer::E_ARTICLE_REPLY])
+    {
+        foreach (const QStringList& strlist, vecData[SInitializer::E_ARTICLE_REPLY])
+        {
+            streal.m_setRealAllUrl.insert(strlist[anColumn[SInitializer::E_DATA_article_url]].trimmed());
+            streal.m_mapRealReplyUniqueUrl.insertMulti(strlist[anColumn[SInitializer::E_DATA_article_url]].trimmed(),
+                    strlist[anColumn[SInitializer::E_DATA_article_order]].trimmed().toInt());
+            _datagroup.addRealUrl(strlist[anColumn[SInitializer::E_DATA_article_url]].trimmed());
+        }
+    }
+
+    m_mapCategory.insert(_nCategory, streal);
+    return true;
+}
+
+bool SConsumer::changeTable(int _companyNum)
+{
+    m_pSInitializer->insertLog("Start change consumer tables");
+    QSqlDatabase dbWeb = m_pSInitializer->getDatabase(SDBManager::E_DATABASE_WEB);
+    if (!m_SBodyConsumerMap.changeTable(dbWeb, _companyNum))
+    {
+        m_pSInitializer->insertLog("Fail to body_consumer_change");
+        return false;
+    }
+
+    return true;
+}
+
+void SConsumer::setInitiaizer(SInitializer &_initializer)
+{
+    m_pSInitializer = &_initializer;
+    m_SBodyConsumerMap.setInitiaizer(_initializer);
+    //m_SStatsConUserBuzzybyday.setInitiaizer(_initializer);
+    m_SStatsJson.setInitiaizer(_initializer);
+}
+
+bool SConsumer::makeOverallCategory(int _nCategory)
+{
+    if (m_mapCategory.size() < 1)
+        return true;
+
+    stReal streal;
+    for (QMap<int, stReal>::iterator iterPos = m_mapCategory.begin(); iterPos != m_mapCategory.end(); iterPos++ )
+    {
+        stReal& val = iterPos.value();
+        foreach (const QString& _strurl, val.m_setRealBodyUrl )
+            streal.m_setRealBodyUrl.insert(_strurl);
+        foreach (const QString& _strurl, val.m_setRealAllUrl )
+            streal.m_setRealAllUrl.insert(_strurl);
+
+        for (QMap<QString, int>::iterator iterPos1 = val.m_mapRealReplyUniqueUrl.begin(); iterPos1 != val.m_mapRealReplyUniqueUrl.end();
+             iterPos1++)
+        {
+            if (streal.m_mapRealReplyUniqueUrl.contains(iterPos1.key()) && streal.m_mapRealReplyUniqueUrl.values(iterPos1.key()).contains(iterPos1.value()))
+                continue;
+            else
+                streal.m_mapRealReplyUniqueUrl.insertMulti(iterPos1.key(), iterPos1.value());
+        }
+    }
+
+    m_mapCategory.insert(_nCategory, streal);
+    return true;
+}
+
+bool SConsumer::makeTable(SDatagroup &_datagroup)
+{
+    if (m_mapCategory.size() > 1)
+    {
+        m_pSInitializer->insertLog("Make Consumer Tables");
+        m_SBodyConsumerMap.makeTable(_datagroup, m_mapCategory);
+        m_pSInitializer->insertLog("Make Body Tables");
+        //m_SStatsConUserBuzzybyday.makeTable(_datagroup, m_mapCategory);
+        m_SStatsJson.makeTable(_datagroup, m_mapCategory);
+        m_pSInitializer->insertLog("Make stats_json Tables");
+    }
+    return true;
+}
+
+void SConsumer::SBodyConsumerMap::makeTable(SDatagroup &_datagroup, const QMap<int, stReal> &_mapCategory)
+{
+    int num = 0;
+    const QStringList* orderedUrl = _datagroup.getOrderedUrl();
+    for (QMap<int, stReal>::const_iterator iterPos = _mapCategory.constBegin(); iterPos != _mapCategory.constEnd(); iterPos++)
+    {
+        const stReal& streal = iterPos.value();
+        foreach (const QString& strUrl, *orderedUrl)
+        {
+            if (streal.m_setRealBodyUrl.contains(strUrl))
+            {
+                stBodyConsumerMap stbody;
+                stbody.num = num++;
+                stbody.body_num = _datagroup.getstBodyNum(strUrl);
+                stbody.category_num = iterPos.key();
+                stbody.realin |= REAL_BODY;
+
+                stbody.platformname_num = _datagroup.getstBody(strUrl)->platformname_num;
+                stbody.platformform_num = _datagroup.getstBody(strUrl)->platformform_num;
+                stbody.date = _datagroup.getstBody(strUrl)->date;
+                stbody.replycount = _datagroup.getstBody(strUrl)->replycount;
+                stbody.view = _datagroup.getstBody(strUrl)->view;
+                stbody.id_num = _datagroup.getstBody(strUrl)->id_num;
+                stbody.community_num = _datagroup.getstBody(strUrl)->community_num;
+                stbody.nickname_num = _datagroup.getstBody(strUrl)->nickname_num;
+
+                if (streal.m_mapRealReplyUniqueUrl.contains(strUrl))
+                {
+                    stbody.realin |= REAL_REPLY;
+
+                    foreach (int order, streal.m_mapRealReplyUniqueUrl.values(strUrl))
+                    {
+                        _datagroup.addRealReplyCategory(strUrl, order, iterPos.key());
+                    }
+                }
+                m_listMap.append(stbody);
+                _datagroup.addRealBodyCategory(strUrl, iterPos.key());
+            }
+            else if (streal.m_mapRealReplyUniqueUrl.contains(strUrl))
+            {
+                stBodyConsumerMap stbody;
+                stbody.num = num++;
+                stbody.body_num = _datagroup.getstBodyNum(strUrl);
+                stbody.category_num = iterPos.key();
+                stbody.realin |= REAL_REPLY;
+
+                stbody.platformname_num = _datagroup.getstBody(strUrl)->platformname_num;
+                stbody.platformform_num = _datagroup.getstBody(strUrl)->platformform_num;
+                stbody.date = _datagroup.getstBody(strUrl)->date;
+                stbody.replycount = _datagroup.getstBody(strUrl)->replycount;
+                stbody.view = _datagroup.getstBody(strUrl)->view;
+                stbody.id_num = _datagroup.getstBody(strUrl)->id_num;
+                stbody.community_num = _datagroup.getstBody(strUrl)->community_num;
+                stbody.nickname_num = _datagroup.getstBody(strUrl)->nickname_num;
+
+                foreach (int order, streal.m_mapRealReplyUniqueUrl.values(strUrl))
+                {
+                    _datagroup.addRealReplyCategory(strUrl, order, iterPos.key());
+                }
+                m_listMap.append(stbody);
+            }
+        }
+    }
+}
+
+bool SConsumer::SBodyConsumerMap::changeTable(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery;
+    QSqlQuery query(_db);
+    strQuery = "RENAME TABLE ";
+    strQuery += "body_consumer_map_" + QString::number(_nCompany) + " TO " + "body_consumer_map_" + QString::number(_nCompany) + "_temp" + ",";
+    strQuery += "body_consumer_map_" + QString::number(_nCompany) + "_update" + " TO " + "body_consumer_map_" + QString::number(_nCompany) + ",";
+    strQuery += "body_consumer_map_" + QString::number(_nCompany) + "_temp" + " TO " + "body_consumer_map_" + QString::number(_nCompany) + "_update";
+    if (!query.exec(strQuery.toUtf8()))
+    {
+        m_pSInitializer->insertLog(query.lastQuery());
+        m_pSInitializer->insertLog(query.lastError().text());
+        return false;
+    }
+    return true;
+}
+/*
+bool SConsumer::SBodyConsumerMap::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery = "truncate body_consumer_map_" + QString::number(_nCompany) + "_update";
+    QSqlQuery query(_db);
+    if (query.exec(strQuery.toUtf8()) == false)
+    {
+        m_pSInitializer->insertLog(query.lastQuery());
+        m_pSInitializer->insertLog(query.lastError().text());
+        return false;
+    }
+
+    strQuery = QString("insert into body_consumer_map_" + QString::number(_nCompany) +
+                       "_update (num,body_num,category_num,realin) VALUES (:NUM,:BODY_NUM,:CATEGORY_NUM,:REALIN)");
+
+    query.clear();
+    query.prepare(strQuery.toUtf8());
+
+    foreach (const stBodyConsumerMap& stbody, m_listMap)
+    {
+        query.bindValue(":NUM", stbody.num);
+        query.bindValue(":BODY_NUM", stbody.body_num);
+        query.bindValue(":CATEGORY_NUM", stbody.category_num);
+        query.bindValue(":REALIN", stbody.realin);
+        if (query.exec() == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    return true;
+}
+*/
+
+bool SConsumer::SBodyConsumerMap::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery = "truncate body_consumer_map_" + QString::number(_nCompany) + "_update";
+    QSqlQuery query(_db);
+    if (query.exec(strQuery.toUtf8()) == false)
+    {
+        m_pSInitializer->insertLog(query.lastQuery());
+        m_pSInitializer->insertLog(query.lastError().text());
+        return false;
+    }
+
+    strQuery = QString("insert into body_consumer_map_" + QString::number(_nCompany) +
+                       "_update (num,body_num,category_num,realin,platformname_num,platformform_num,date,replycount,view,id_num,community_num,nickname_num) VALUES (");
+
+    query.clear();
+
+    foreach (const stBodyConsumerMap& stbody, m_listMap)
+    {
+        QString str = strQuery;
+        str += QString::number(stbody.num) + ",";
+        str += QString::number(stbody.body_num) + ",";
+        str += QString::number(stbody.category_num) + ",";
+        str += QString::number(stbody.realin) + ",";
+        str += QString::number(stbody.platformname_num) + ",";
+        str += QString::number(stbody.platformform_num) + ",";
+        str += "'" + stbody.date + "',";
+        str += QString::number(stbody.replycount) + ",";
+        str += QString::number(stbody.view) + ",";
+        str += QString::number(stbody.id_num) + ",";
+        str += QString::number(stbody.community_num) + ",";
+        str += QString::number(stbody.nickname_num) + ")";
+
+        if (query.exec(str.toUtf8()) == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    return true;
+}
+
+void SConsumer::SReplyConsumerMap::makeTable(SDatagroup &_datagroup, const QMap<int, stReal> &_mapCategory)
+{
+    int num = 0;
+    const QStringList* orderedUrl = _datagroup.getOrderedUrl();
+    for (QMap<int, stReal>::const_iterator iterPos = _mapCategory.constBegin(); iterPos != _mapCategory.constEnd(); iterPos++)
+    {
+        const stReal& streal = iterPos.value();
+        foreach (const QString& strUrl, *orderedUrl)
+        {
+            if (streal.m_setRealAllUrl.contains(strUrl))
+            {
+                if (_datagroup.getstBody(strUrl)->replycount == 0)
+                    continue;
+
+                const QMap<int, SDatagroup::stReply>* mapReply = _datagroup.getstReply(strUrl);
+
+                for(QMap<int, SDatagroup::stReply>::const_iterator iterPos1 = mapReply->constBegin(); iterPos1 != mapReply->constEnd(); iterPos1++)
+                {
+                    stReplyConsumerMap streply;
+                    streply.num = num++;
+                    streply.category_num = iterPos.key();
+                }
+            }
+        }
+    }
+}
+
+void SConsumer::SStatsJson::makeTable(SDatagroup &_datagroup, const QMap<int, stReal> &_mapCategory)
+{
+    const QMap<QString, QStringList>* mapBody = _datagroup.getmapBody();
+    const QMap<QString, QMap<int, QStringList> >* mapReply = _datagroup.getmapReply();
+    const int* anColumn = m_pSInitializer->getColumnIntArray();
+
+    QDate dateStart(2100,1,1),dateEnd(2000,1,1);
+    QDate dateStartBody(2100,1,1),dateEndBody(2000,1,1);
+    QDate dateStartReply(2100,1,1),dateEndReply(2000,1,1);
+
+    QList<stBuzzy> listBuzzy;
+    stReal allCategory;
+    // filtered
+    {
+        for (QMap<int, stReal>::const_iterator iterPos = _mapCategory.constBegin(); iterPos != _mapCategory.constEnd(); iterPos++)
+        {
+            stBuzzy stbuzzy;
+            stbuzzy.m_nCategory = iterPos.key();
+            const stReal &streal = iterPos.value();
+            foreach (const QString& strUrl, streal.m_setRealBodyUrl)
+            {
+                allCategory.m_setRealBodyUrl.insert(strUrl);
+                allCategory.m_setRealAllUrl.insert(strUrl);
+                QDate date = QDateTime::fromString((*mapBody)[strUrl.trimmed()][anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd HH:mm:ss").date();
+                //if (date.isNull())
+                //    date = QDateTime::fromString((*mapBody)[strUrl.trimmed()][anColumn[SInitializer::E_DATA_article_date]].trimmed(), "yyyy-MM-dd HH:mm:ss").date();
+                if (date.year() == 1990)
+                    continue;
+                dateStart = (date < dateStart ) ? date : dateStart;
+                dateEnd = (date > dateEnd ) ? date : dateEnd;
+                dateStartBody = (date < dateStartBody ) ? date : dateStartBody;
+                dateEndBody = (date > dateEndBody ) ? date : dateEndBody;
+
+
+                if (stbuzzy.m_mapBodyBuzz.contains(date))
+                    stbuzzy.m_mapBodyBuzz[date]++;
+                else
+                    stbuzzy.m_mapBodyBuzz.insert(date, 1);
+            }
+
+            for (QMap<QString, int>::const_iterator iterPos1 = streal.m_mapRealReplyUniqueUrl.constBegin(); iterPos1 != streal.m_mapRealReplyUniqueUrl.constEnd(); iterPos1++)
+            {
+                const QStringList &slReply = (*mapReply)[iterPos1.key()][iterPos1.value()];
+                if (!allCategory.m_mapRealReplyUniqueUrl.contains(iterPos1.key()) || !allCategory.m_mapRealReplyUniqueUrl.values(iterPos1.key()).contains(iterPos1.value()))
+                    allCategory.m_mapRealReplyUniqueUrl.insertMulti(iterPos1.key(), iterPos1.value());
+                allCategory.m_setRealAllUrl.insert(iterPos1.key());
+                QDate date = QDateTime::fromString(slReply[anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd HH:mm:ss").date();
+                if (date.year() == 1990)
+                    continue;
+                dateStart = (date < dateStart ) ? date : dateStart;
+                dateEnd = (date > dateEnd ) ? date : dateEnd;
+                dateStartReply = (date < dateStartReply ) ? date : dateStartReply;
+                dateEndReply = (date > dateEndReply ) ? date : dateEndReply;
+
+                if (stbuzzy.m_mapReplyBuzz.contains(date))
+                    stbuzzy.m_mapReplyBuzz[date]++;
+                else
+                    stbuzzy.m_mapReplyBuzz.insert(date, 1);
+            }
+
+            listBuzzy.append(stbuzzy);
+        }
+    }
+    //all filtered category
+    {
+        stBuzzy stbuzzy;
+        stbuzzy.m_nCategory = -1;
+        foreach (const QString& strUrl, allCategory.m_setRealBodyUrl)
+        {
+            QDate date = QDateTime::fromString((*mapBody)[strUrl.trimmed()][anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd HH:mm:ss").date();
+            if (date.year() == 1990)
+                continue;
+
+            if (stbuzzy.m_mapBodyBuzz.contains(date))
+                stbuzzy.m_mapBodyBuzz[date]++;
+            else
+                stbuzzy.m_mapBodyBuzz.insert(date, 1);
+        }
+
+        for (QMap<QString, int>::const_iterator iterPos1 = allCategory.m_mapRealReplyUniqueUrl.constBegin(); iterPos1 != allCategory.m_mapRealReplyUniqueUrl.constEnd(); iterPos1++)
+        {
+            const QStringList &slReply = (*mapReply)[iterPos1.key()][iterPos1.value()];
+            QDate date = QDateTime::fromString(slReply[anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd HH:mm:ss").date();
+            if (date.year() == 1990)
+                continue;
+
+            if (stbuzzy.m_mapReplyBuzz.contains(date))
+                stbuzzy.m_mapReplyBuzz[date]++;
+            else
+                stbuzzy.m_mapReplyBuzz.insert(date, 1);
+        }
+        listBuzzy.append(stbuzzy);
+    }
+
+    //all buzzy
+    {
+        stBuzzy stbuzzy;
+        stbuzzy.m_nCategory = 0;
+        for (QMap<QString, QStringList>::const_iterator iterPos = mapBody->constBegin(); iterPos != mapBody->constEnd(); iterPos++)
+        {
+            QDate date = QDateTime::fromString(iterPos.value()[anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd HH:mm:ss").date();
+            if (date.year() == 1990)
+                continue;
+
+            if (stbuzzy.m_mapBodyBuzz.contains(date))
+                stbuzzy.m_mapBodyBuzz[date]++;
+            else
+                stbuzzy.m_mapBodyBuzz.insert(date, 1);
+        }
+
+        for (QMap<QString, QMap<int, QStringList> >::const_iterator iterPos = mapReply->constBegin(); iterPos != mapReply->constEnd(); iterPos++)
+        {
+            for (QMap<int, QStringList>::const_iterator iterPos1 = iterPos.value().constBegin(); iterPos1 != iterPos.value().constEnd(); iterPos1++)
+            {
+                QDate date = QDateTime::fromString(iterPos1.value()[anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd HH:mm:ss").date();
+                if (date.year() == 1990)
+                    continue;
+
+                if (stbuzzy.m_mapReplyBuzz.contains(date))
+                    stbuzzy.m_mapReplyBuzz[date]++;
+                else
+                    stbuzzy.m_mapReplyBuzz.insert(date, 1);
+            }
+        }
+        listBuzzy.append(stbuzzy);
+    }
+
+    int nTotalCount = 0, nTotalBodyCount = 0, nTotalReplyCount = 0;
+
+    {
+        foreach (const QString& strUrl, allCategory.m_setRealAllUrl)
+        {
+            nTotalBodyCount++;
+            nTotalReplyCount += (*mapReply)[strUrl].size();
+        }
+        nTotalCount = nTotalBodyCount + nTotalReplyCount;
+    }
+
+
+    {
+        QJsonArray jsArrayAll;
+        QJsonArray jsArrayReply;
+        QJsonArray jsArrayBody;
+
+        foreach (const stBuzzy &stbuzzy, listBuzzy)
+        {
+            QJsonArray jsValueAll;
+            QJsonArray jsValueBody;
+            QJsonArray jsValueReply;
+
+            for (QDate i = dateStart; i <= dateEnd; i = i.addDays(1))
+            {
+                QJsonObject jsoBody;
+                QJsonObject jsoAll;
+                QJsonObject jsoReply;
+
+                jsoAll["date"] = jsoReply["date"] = jsoBody["date"] = i.toString("yyyyMMdd");
+                jsoBody["count"] = stbuzzy.m_mapBodyBuzz[i];
+                jsoReply["count"] = stbuzzy.m_mapReplyBuzz[i];
+                jsoAll["count"] = stbuzzy.m_mapBodyBuzz[i] + stbuzzy.m_mapReplyBuzz[i];
+
+                jsValueAll.append(jsoAll);
+                jsValueBody.append(jsoBody);
+                jsValueReply.append(jsoReply);
+            }
+
+            QJsonObject jsNameReply;
+            QJsonObject jsNameAll;
+            QJsonObject jsNameBody;
+
+            if (stbuzzy.m_nCategory > 0)
+                jsNameReply["name"] = jsNameBody["name"] = jsNameAll["name"] = m_pSInitializer->getCategoryName(stbuzzy.m_nCategory);
+            else if (stbuzzy.m_nCategory == 0)
+                jsNameReply["name"] = jsNameBody["name"] = jsNameAll["name"] = "ALL";
+            else
+                jsNameReply["name"] = jsNameBody["name"] = jsNameAll["name"] = "ALLCATEGORY";
+
+            jsNameAll["value"] = jsValueAll;
+            jsNameBody["value"] = jsValueBody;
+            jsNameReply["value"] = jsValueReply;
+
+            jsArrayAll.append(jsNameAll);
+            jsArrayBody.append(jsNameBody);
+            jsArrayReply.append(jsNameReply);
+        }
+        stStatsJson stbodybuzz;
+        stStatsJson streplybuzz;
+        stStatsJson stallbuzz;
+
+        stallbuzz.title = streplybuzz.title = stbodybuzz.title = "buzz";
+        stbodybuzz.subtitle = "body";
+        streplybuzz.subtitle = "reply";
+        stallbuzz.subtitle = "all";
+
+        QJsonObject jobjAll;
+        QJsonObject jobjBody;
+        QJsonObject jobjReply;
+
+        jobjAll["data"] = jsArrayAll;
+        jobjBody["data"] = jsArrayBody;
+        jobjReply["data"] = jsArrayReply;
+
+        jobjAll["mindate"] = dateStart.toString("yyyy.MM.dd");
+        jobjBody["mindate"] = dateStartBody.toString("yyyy.MM.dd");
+        jobjReply["mindate"] = dateStartReply.toString("yyyy.MM.dd");
+
+        jobjAll["maxdate"] = dateEnd.toString("yyyy.MM.dd");
+        jobjBody["maxdate"] = dateEndBody.toString("yyyy.MM.dd");
+        jobjReply["maxdate"] = dateEndReply.toString("yyyy.MM.dd");
+
+        jobjAll["totalcount"] = nTotalCount;
+        jobjBody["totalcount"] = nTotalBodyCount;
+        jobjReply["totalcount"] = nTotalReplyCount;
+
+        QJsonDocument jdAll(jobjAll);
+        QJsonDocument jdBody(jobjBody);
+        QJsonDocument jdReply(jobjReply);
+
+
+        stbodybuzz.jdata = jdBody.toJson(QJsonDocument::Compact);
+        streplybuzz.jdata = jdReply.toJson(QJsonDocument::Compact);
+        stallbuzz.jdata = jdAll.toJson(QJsonDocument::Compact);
+
+        stallbuzz.platformname_num = stbodybuzz.platformname_num = streplybuzz.platformname_num = 1;
+        m_listMap.append(stbodybuzz);
+        m_listMap.append(streplybuzz);
+        m_listMap.append(stallbuzz);
+    }
+
+    /*
+
+    {
+        for (QDate i = dateStart; i <= dateEnd; i = i.addDays(1))
+        {
+            //body
+            stStatsJson stbodybuzz;
+            stStatsJson streplybuzz;
+            stStatsJson stallbuzz;
+            foreach (const stBuzzy& stbuzzy, listBuzzy)
+            {
+                if (stbuzzy.m_mapBodyBuzz.contains(i))
+                {
+                    stbodybuzz.category[stbuzzy.m_nCategory] = stbuzzy.m_mapBodyBuzz[i];
+                    stallbuzz.category[stbuzzy.m_nCategory] += stbuzzy.m_mapBodyBuzz[i];
+                }
+
+                if (stbuzzy.m_mapReplyBuzz.contains(i))
+                {
+                    streplybuzz.category[stbuzzy.m_nCategory] = stbuzzy.m_mapReplyBuzz[i];
+                    stallbuzz.category[stbuzzy.m_nCategory] += stbuzzy.m_mapReplyBuzz[i];
+                }
+            }
+            stallbuzz.date = streplybuzz.date = stbodybuzz.date = i;
+            stbodybuzz.subtitle = "body";
+            streplybuzz.subtitle = "reply";
+            stallbuzz.subtitle = "all";
+            m_listMap.append(stallbuzz);
+            m_listMap.append(stbodybuzz);
+            m_listMap.append(streplybuzz);
+        }
+    }
+    */
+}
+
+bool SConsumer::SStatsJson::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    QSqlQuery query(_db);
+    {
+        QString strQuery = "delete from stats_json where company_num = " + QString::number(_nCompany) + " and servicenum = 2 and title = 'buzz'";
+        if (!query.exec(strQuery.toUtf8()))
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+
+    foreach (const stStatsJson& ststats, m_listMap)
+    {
+        QString strQuery = "insert into stats_json (company_num, servicenum, title, subtitle, category_num, platformname_num, jdata) values (";
+        strQuery += QString::number(_nCompany) + ",";
+        strQuery += QString::number(ststats.servicenum) + ",";
+        strQuery += "'" + ststats.title + "',";
+        strQuery += "'" + ststats.subtitle + "',";
+        strQuery += QString::number(ststats.category_num) + ",";
+        strQuery += QString::number(ststats.platformname_num) + ",";
+        strQuery += "'" + ststats.jdata +"')";
+
+        if (!query.exec(strQuery.toUtf8()))
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    return true;
+}
+
+/*
+void SConsumer::SStatsConUserBuzzybyday::makeTable(SDatagroup &_datagroup, const QMap<int, stReal> &_mapCategory)
+{
+
+    const QMap<QString, QStringList>* mapBody = _datagroup.getmapBody();
+    const QMap<QString, QMap<int, QStringList> >* mapReply = _datagroup.getmapReply();
+    const int* anColumn = m_pSInitializer->getColumnIntArray();
+
+    QDate dateStart(2100,1,1),dateEnd(2000,1,1);
+
+    QMap<int, int>* mapConsumerCategory = m_pSInitializer->getConsumerCategory();
+    QList<stBuzzy> listBuzzy;
+    //filtered buzzy
+    {
+        for (QMap<int, stReal>::const_iterator iterPos = _mapCategory.constBegin(); iterPos != _mapCategory.constEnd(); iterPos++)
+        {
+            stBuzzy stbuzzy;
+            stbuzzy.m_nCategory = (*mapConsumerCategory)[iterPos.key()];
+            const stReal &streal = iterPos.value();
+            foreach (const QString& strUrl, streal.m_setRealBodyUrl)
+            {
+                QDate date = QDateTime::fromString((*mapBody)[strUrl.trimmed()][anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd HH:mm:ss").date();
+                //if (date.isNull())
+                //    date = QDateTime::fromString((*mapBody)[strUrl.trimmed()][anColumn[SInitializer::E_DATA_article_date]].trimmed(), "yyyy-MM-dd HH:mm:ss").date();
+                if (date.year() == 1990)
+                    continue;
+                dateStart = (date < dateStart ) ? date : dateStart;
+                dateEnd = (date > dateEnd ) ? date : dateEnd;
+
+                if (stbuzzy.m_mapBodyBuzz.contains(date))
+                    stbuzzy.m_mapBodyBuzz[date]++;
+                else
+                    stbuzzy.m_mapBodyBuzz.insert(date, 1);
+            }
+
+            for (QMap<QString, int>::const_iterator iterPos1 = streal.m_mapRealReplyUniqueUrl.constBegin(); iterPos1 != streal.m_mapRealReplyUniqueUrl.constEnd(); iterPos1++)
+            {
+                const QStringList &slReply = (*mapReply)[iterPos1.key()][iterPos1.value()];
+                QDate date = QDateTime::fromString(slReply[anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd HH:mm:ss").date();
+                if (date.year() == 1990)
+                    continue;
+                dateStart = (date < dateStart ) ? date : dateStart;
+                dateEnd = (date > dateEnd ) ? date : dateEnd;
+                if (stbuzzy.m_mapReplyBuzz.contains(date))
+                    stbuzzy.m_mapReplyBuzz[date]++;
+                else
+                    stbuzzy.m_mapReplyBuzz.insert(date, 1);
+            }
+
+            listBuzzy.append(stbuzzy);
+        }
+    }
+
+    //all buzzy
+    {
+        stBuzzy stbuzzy;
+        stbuzzy.m_nCategory = 0;
+        for (QMap<QString, QStringList>::const_iterator iterPos = mapBody->constBegin(); iterPos != mapBody->constEnd(); iterPos++)
+        {
+            QDate date = QDateTime::fromString(iterPos.value()[anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd HH:mm:ss").date();
+            if (date.year() == 1990)
+                continue;
+
+            if (stbuzzy.m_mapBodyBuzz.contains(date))
+                stbuzzy.m_mapBodyBuzz[date]++;
+            else
+                stbuzzy.m_mapBodyBuzz.insert(date, 1);
+        }
+
+        for (QMap<QString, QMap<int, QStringList> >::const_iterator iterPos = mapReply->constBegin(); iterPos != mapReply->constEnd(); iterPos++)
+        {
+            for (QMap<int, QStringList>::const_iterator iterPos1 = iterPos.value().constBegin(); iterPos1 != iterPos.value().constEnd(); iterPos1++)
+            {
+                QDate date = QDateTime::fromString(iterPos1.value()[anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd HH:mm:ss").date();
+                if (date.year() == 1990)
+                    continue;
+
+                if (stbuzzy.m_mapReplyBuzz.contains(date))
+                    stbuzzy.m_mapReplyBuzz[date]++;
+                else
+                    stbuzzy.m_mapReplyBuzz.insert(date, 1);
+            }
+        }
+        listBuzzy.append(stbuzzy);
+    }
+
+    {
+        for (QDate i = dateStart; i <= dateEnd; i = i.addDays(1))
+        {
+            //body
+            stStatsConUserBuzzybyday stbodybuzz;
+            stStatsConUserBuzzybyday streplybuzz;
+            stStatsConUserBuzzybyday stallbuzz;
+            foreach (const stBuzzy& stbuzzy, listBuzzy)
+            {
+                if (stbuzzy.m_mapBodyBuzz.contains(i))
+                {
+                    stbodybuzz.category[stbuzzy.m_nCategory] = stbuzzy.m_mapBodyBuzz[i];
+                    stallbuzz.category[stbuzzy.m_nCategory] += stbuzzy.m_mapBodyBuzz[i];
+                }
+
+                if (stbuzzy.m_mapReplyBuzz.contains(i))
+                {
+                    streplybuzz.category[stbuzzy.m_nCategory] = stbuzzy.m_mapReplyBuzz[i];
+                    stallbuzz.category[stbuzzy.m_nCategory] += stbuzzy.m_mapReplyBuzz[i];
+                }
+            }
+            stallbuzz.date = streplybuzz.date = stbodybuzz.date = i;
+            stbodybuzz.subject = "body";
+            streplybuzz.subject = "reply";
+            stallbuzz.subject = "all";
+            m_listMap.append(stallbuzz);
+            m_listMap.append(stbodybuzz);
+            m_listMap.append(streplybuzz);
+        }
+    }
+
+}
+*/
+/*
+bool SConsumer::SStatsConUserBuzzybyday::changeTable(QSqlDatabase &_db, const int &_nCompany)
+{
+
+}
+*/
+
+/*
+bool SConsumer::SStatsConUserBuzzybyday::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    //_db.transaction();
+    QSqlQuery query(_db);
+    {
+        QString strQuery = "delete from stats_con_user_buzzbyday where company_num = " + QString::number(_nCompany);
+        if (!query.exec(strQuery.toUtf8()))
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    //_db.commit();
+    //_db.transaction();
+    QString strQuery = "insert into stats_con_user_buzzbyday (";
+    for (int i = 0; i < 11; i++)
+    {
+        strQuery += ("category_" + QString::number(i) + ",");
+    }
+
+    strQuery += "date,subject,company_num) values (";
+    for (int i = 0; i < 11; i++)
+    {
+        strQuery += (":category_" + QString::number(i) + ",");
+    }
+
+    strQuery += ":date,:subject,:company_num)";
+
+    query.prepare(strQuery);
+
+    foreach (const stStatsConUserBuzzybyday& ststats, m_listMap)
+    {
+        for (int i = 0; i < 11; i++)
+        {
+            query.bindValue(":category_" + QString::number(i), ststats.category[i]);
+        }
+        query.bindValue(":date", ststats.date.toString("yyyy-MM-dd"));
+        query.bindValue(":subject", ststats.subject);
+        query.bindValue(":company_num", _nCompany);
+        if (!query.exec())
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    //_db.commit();
+    return true;
+}
+*/
+
+/*
+bool SConsumer::SStatsConUserBuzzybyday::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    //_db.transaction();
+    QSqlQuery query(_db);
+    {
+        QString strQuery = "delete from stats_con_user_buzzbyday where company_num = " + QString::number(_nCompany);
+        if (!query.exec(strQuery.toUtf8()))
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    //_db.commit();
+    //_db.transaction();
+    QString strQuery = "insert into stats_con_user_buzzbyday (";
+    for (int i = 0; i < 11; i++)
+    {
+        strQuery += ("category_" + QString::number(i) + ",");
+    }
+
+    strQuery += "date,subject,company_num) values (";
+
+    foreach (const stStatsConUserBuzzybyday& ststats, m_listMap)
+    {
+        QString str = strQuery;
+        for (int i = 0; i < 11; i++)
+        {
+            str += QString::number(ststats.category[i]) + ",";
+        }
+        str += "'" + ststats.date.toString("yyyy-MM-dd") + "',";
+        str += "'" + ststats.subject + "',";
+        str += QString::number(_nCompany) + ")";
+        if (!query.exec(str.toUtf8()))
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    //_db.commit();
+    return true;
+}
+*/
+
+
+bool SConsumerMarketer::makeTable(SDatagroup &_datagroup)
+{
+
+    const QMap<QString, QStringList>* mapBody = _datagroup.getmapBody();
+    const QMap<QString, QMap<int, QStringList> >* mapReply = _datagroup.getmapReply();
+    const int* anColumn = m_pSInitializer->getColumnIntArray();
+
+    QMap<int, QString> mapConsumerMarketer = m_pSInitializer->getConsumerMaketer();
+
+    for (QMap<int, QString>::iterator iterPos = mapConsumerMarketer.begin(); iterPos != mapConsumerMarketer.end(); ++iterPos)
+    {
+        if (iterPos.value().trimmed().isEmpty())
+            continue;
+
+
+        for (QMap<QString, QStringList>::const_iterator iterPos1 = mapBody->cbegin(); iterPos1 != mapBody->cend(); ++iterPos1)
+        {
+            if ((m_pSInitializer->getPlatformName(iterPos1.value()[anColumn[SInitializer::E_DATA_platform_name]].trimmed()) == iterPos.key())
+                    && (iterPos.value() == iterPos1.value()[anColumn[SInitializer::E_DATA_article_id]].trimmed()))
+            {
+                _datagroup.addRealUrl(iterPos1.value()[anColumn[SInitializer::E_DATA_article_url]].trimmed());
+            }
+        }
+
+        for (QMap<QString, QMap<int, QStringList> >::const_iterator iterPos1 = mapReply->cbegin(); iterPos1 != mapReply->cend(); ++iterPos1)
+        {
+            for(QMap<int, QStringList>::const_iterator iterPos2 = iterPos1->cbegin(); iterPos2 != iterPos1->cend(); ++iterPos2)
+            {
+                if ((m_pSInitializer->getPlatformName(iterPos2.value()[anColumn[SInitializer::E_DATA_platform_name]].trimmed()) == iterPos.key())
+                        && (iterPos.value() == iterPos2.value()[anColumn[SInitializer::E_DATA_article_id]].trimmed()))
+                {
+                    _datagroup.addRealUrl(iterPos2.value()[anColumn[SInitializer::E_DATA_article_url]].trimmed());
+                    //_datagroup.addRealUrl(iterPos1.key().trimmed());
+                }
+            }
+        }
+    }
+    return true;
+
+}
+
+
+bool SConsumerCheckList::makeTable(SDatagroup &_datagroup)
+{
+
+    QStringList slUrl = m_pSInitializer->getConsumerCheckList();
+    QMap<int, QString> mapUsers = m_pSInitializer->getConsumerCheckListUser();
+    if (slUrl.isEmpty() && mapUsers.isEmpty())
+        return true;
+
+    const QMap<QString, QStringList>* mapBody = _datagroup.getmapBody();
+    const QMap<QString, QMap<int, QStringList> >* mapReply = _datagroup.getmapReply();
+    const int* anColumn = m_pSInitializer->getColumnIntArray();
+
+    const QStringList* pslorderedUrl = _datagroup.getOrderedUrl();
+
+    foreach (const QString& strUrl, *pslorderedUrl)
+    {
+        foreach (const QString& url, slUrl)
+        {
+            if (!url.trimmed().isEmpty() && strUrl.contains(url.trimmed()))
+                _datagroup.addRealUrl(strUrl);
+        }
+
+        for(QMap<int, QString>::iterator iterPos = mapUsers.begin(); iterPos != mapUsers.end(); ++iterPos)
+        {
+            if (iterPos.value().trimmed().isEmpty())
+                continue;
+
+            if (m_pSInitializer->getPlatformName((*mapBody)[strUrl][anColumn[SInitializer::E_DATA_platform_name]].trimmed()) == iterPos.key()
+                    && (*mapBody)[strUrl][anColumn[SInitializer::E_DATA_article_id]].trimmed() == iterPos.value().trimmed())
+            {
+                _datagroup.addRealUrl((*mapBody)[strUrl][anColumn[SInitializer::E_DATA_article_url]].trimmed());
+                //_datagroup.addRealUrl(strUrl);
+            }
+
+            if (mapReply->contains(strUrl))
+            {
+                for (QMap<int, QStringList>::const_iterator iterPos1 = (*mapReply)[strUrl].cbegin(); iterPos1 != (*mapReply)[strUrl].cend(); ++iterPos1)
+                {
+                    if (m_pSInitializer->getPlatformName(iterPos1.value()[anColumn[SInitializer::E_DATA_platform_name]].trimmed()) == iterPos.key()
+                            && iterPos1.value()[anColumn[SInitializer::E_DATA_article_id]].trimmed() == iterPos.value().trimmed())
+                    {
+                        //_datagroup.addRealUrl(strUrl);
+                        _datagroup.addRealUrl(iterPos1.value()[anColumn[SInitializer::E_DATA_article_url]].trimmed());
+                    }
+                }
+            }
+        }
+    }
+
+    return true;
+}
+

FilterProcess/sconsumer.h

@@ -0,0 +1,176 @@
+#ifndef SCONSUMER
+#define SCONSUMER
+#include "sservice.h"
+#include "sfilteralgorithm.h"
+#include <QDate>
+
+class SConsumer:public SService
+{
+public:
+    struct stReal
+    {
+        QSet<QString> m_setRealAllUrl;
+        QSet<QString> m_setRealBodyUrl;
+        QMap<QString, int> m_mapRealReplyUniqueUrl; //multiple
+    };
+    struct stBodyConsumerMap
+    {
+        int num;
+        int body_num;
+        int category_num;
+        int realin;
+        int platformname_num;
+        int platformform_num;
+        QString date;
+        int replycount;
+        int view;
+        int id_num;
+        int community_num;
+        int nickname_num;
+        stBodyConsumerMap():num(0), body_num(0), category_num(0), realin(0), platformname_num(0), platformform_num(0), replycount(0), view(0), id_num(0), community_num(0), nickname_num(0){}
+    };
+    struct stReplyConsumerMap
+    {
+        int num;
+        int reply_num;
+        int body_num;
+        int id_num;
+        int category_num;
+        int realin;
+        stReplyConsumerMap():num(0), reply_num(0), body_num(0), id_num(0), category_num(0), realin(0) {}
+    };
+    /*
+    struct stStatsConUserBuzzybyday
+    {
+        int category[11];
+        QDate date;
+        QString subject;
+        int company_num;
+        stStatsConUserBuzzybyday():company_num(0)
+        {
+            for (int i = 0; i < 11; i++)
+                category[i] = 0;
+        }
+    };
+    */
+    struct stStatsJson
+    {
+        int company_num;
+        int servicenum;
+        QString title;
+        QString subtitle;
+        int platformname_num;
+        QString jdata;
+        int category_num;
+        stStatsJson():company_num(0), servicenum(2), platformname_num(1), category_num(0){}
+    };
+
+    struct stBuzzy
+    {
+        int m_nCategory;
+        QMap<QDate, int> m_mapBodyBuzz;
+        QMap<QDate, int> m_mapReplyBuzz;
+    };
+
+    class SBodyConsumerMap
+    {
+    private:
+        SInitializer *m_pSInitializer;
+        QList<stBodyConsumerMap> m_listMap;
+    public:
+        void setInitiaizer(SInitializer &_SInitializer) { m_pSInitializer = &_SInitializer; }
+        void makeTable(SDatagroup &_datagroup, const QMap<int, stReal>& _mapCategory);
+        bool changeTable(QSqlDatabase& _db, const int &_nCompany);
+        bool uploadData(QSqlDatabase& _db, const int &_nCompany);
+        void clear() { m_listMap.clear(); }
+    };
+    class SReplyConsumerMap // Why did you define this?
+    {
+    private:
+        SInitializer *m_pSInitializer;
+        QList<stReplyConsumerMap> m_listMap;
+    public:
+        void setInitiaizer(SInitializer &_SInitializer) { m_pSInitializer = &_SInitializer; }
+        void makeTable(SDatagroup &_datagroup, const QMap<int, stReal>& _mapCategory);
+        bool changeTable(QSqlDatabase& _db, const int &_nCompany);
+        bool uploadData(QSqlDatabase& _db, const int &_nCompany);
+        void clear(){ m_listMap.clear(); }
+
+    };
+    /*
+    class SStatsConUserBuzzybyday
+    {
+    private:
+        SInitializer *m_pSInitializer;
+        QList<stStatsConUserBuzzybyday> m_listMap;
+    public:
+        void setInitiaizer(SInitializer &_SInitializer) { m_pSInitializer = &_SInitializer; }
+        void makeTable(SDatagroup &_datagroup, const QMap<int, stReal>& _mapCategory);
+        //bool changeTable(QSqlDatabase& _db, const int &_nCompany);
+        bool uploadData(QSqlDatabase& _db, const int &_nCompany);
+        void clear(){ m_listMap.clear(); }
+    };
+    */
+
+    class SStatsJson
+    {
+    private:
+        SInitializer *m_pSInitializer;
+        QList<stStatsJson> m_listMap;
+    public:
+        void setInitiaizer(SInitializer &_SInitializer) { m_pSInitializer = &_SInitializer; }
+        void makeTable(SDatagroup &_datagroup, const QMap<int, stReal>& _mapCategory);
+        bool uploadData(QSqlDatabase& _db, const int &_nCompany);
+        void clear(){ m_listMap.clear(); }
+    };
+
+private:
+    SFilterAlgorithm m_SFilterAlgorithm;
+    QMap<int, stReal> m_mapCategory;
+    SBodyConsumerMap m_SBodyConsumerMap;
+    //SStatsConUserBuzzybyday m_SStatsConUserBuzzybyday;
+    SStatsJson m_SStatsJson;
+
+public:
+    virtual void setInitiaizer(SInitializer &_initializer);
+    virtual bool uploadData(int _companyNum);
+    virtual bool changeTable(int _companyNum);
+    virtual bool makeCategory(SDatagroup &_datagroup, int _nCategory, const QList<SInitializer::stFilter> &_listFilter);
+    virtual bool makeOverallCategory(int _nCategory);
+    virtual bool makeTable(SDatagroup &_datagroup);
+};
+
+
+class SConsumerAssist:public SService
+{
+public:
+    virtual void setInitiaizer(SInitializer &_initializer)
+    {
+        m_pSInitializer = &_initializer;
+    }
+    virtual bool uploadData(int _companyNum){ return true; }
+    virtual bool changeTable(int _companyNum){ return true; }
+    virtual bool makeCategory(SDatagroup &_datagroup, int _nCategory, const QList<SInitializer::stFilter> &_listFilter){ return true; }
+    virtual bool makeOverallCategory(int _nCategory){ return true; }
+    virtual bool makeTable(SDatagroup &_datagroup){return true;}
+};
+
+class SConsumerMarketer:public SConsumerAssist
+{
+public:
+
+    virtual bool makeTable(SDatagroup &_datagroup);
+};
+
+
+class SConsumerCheckList:public SConsumerAssist
+{
+public:
+
+    virtual bool makeTable(SDatagroup &_datagroup);
+};
+
+
+
+#endif // SCONSUMER
+

FilterProcess/sdatagroup.h

@@ -0,0 +1,287 @@
+#ifndef SDATAGROUP
+#define SDATAGROUP
+#include <QVector>
+#include <QSet>
+#include <QMap>
+#include <QList>
+#include "../common.h"
+class SInitializer;
+class QString;
+class QStringList;
+class QSqlDatabase;
+
+QString sqlString(QString _str);
+QString UniCodeToEucKr(const QString& _strData);
+
+class SDatagroup
+{
+public:
+    enum E_ARTICLE
+    {
+        E_ARTICLE_BODY = 0,
+        E_ARTICLE_REPLY,
+        E_ARTICLE_MAX,
+    };
+    struct stBody
+    {
+        int num;
+        int id_num;
+        QString id_id;
+        int nickname_num;
+        int community_num;
+        int platformname_num;
+        int platformform_num;
+        QString* title;
+        QString* data;
+        QString url;
+        int view;
+        QString date;
+        int replystartnum;
+        int replyendnum;
+        int replycount;
+        QVector<int> realbycategorynum;
+
+
+        QString lastupdate;
+        QString community_title;
+        QString community_url;
+        QString community_id;
+        QString community_exid;
+        QString platformname_name;
+        QString platformform_form;
+        QString nickname_nickname;
+        QString nickname_exnickname;
+
+        //QSet<int> realbycategorynum;
+        stBody():replyendnum(-1), replystartnum(-1), replycount(0) {}
+    };
+
+    struct stReply
+    {
+        int num;
+        int id_num;
+        QString id_id;
+        int nickname_num;
+        int community_num;
+        int body_num;
+        QString parent;
+        QString* data;
+        QString date;
+        QVector<int> realbycategorynum;
+
+
+        int platformname_num;
+        int platformform_num;
+        QString platformname_name;
+        QString platformform_form;
+        QString nickname_nickname;
+        QString nickname_exnickname;
+        QString body_date;
+        //QSet<int> realbycategorynum;
+        stReply():num(0),id_num(0),nickname_num(0),community_num(0),body_num(0),platformname_num(0),platformform_num(0){}
+    };
+    struct stCommunity
+    {
+        int num;
+        QString id;
+        QString exid;
+        QString title;
+        QString url;
+        int platformname_num;
+        int platformform_num;
+        stCommunity():num(0), platformform_num(1), platformname_num(1), title("(none)"), url(" "), id(" "), exid(" ") {}
+    };
+    struct stId
+    {
+        int num;
+        QString id;
+        int platformname_num;
+        stId():num(0), id("(none)"), platformname_num(1) {}
+    };
+    struct stNickname
+    {
+        int num;
+        QString nickname;
+        int id_num;
+        int platformname_num;
+        stNickname():num(0), platformname_num(0) {}
+    };
+    struct stProfileurlKey
+    {
+        int m_nPlatformForm;
+        QString m_strId;
+        stProfileurlKey(int _nPlatform, const QString& _strId):m_nPlatformForm(_nPlatform), m_strId(_strId) {}
+        bool operator<(const stProfileurlKey& other) const
+        {
+            if (m_nPlatformForm < other.m_nPlatformForm)
+            {
+                return true;
+            }
+            else if ((m_nPlatformForm == other.m_nPlatformForm) && (m_strId < other.m_strId))
+            {
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+        bool operator==(const stProfileurlKey &other) const
+        {
+            if ((m_nPlatformForm == other.m_nPlatformForm) && (m_strId == other.m_strId))
+                return true;
+            else
+                return false;
+        }
+    };
+
+    class SBody
+    {
+    private:
+        //QList<stBody> m_listBody;
+        SInitializer *m_pSInitializer;
+        QMap<QString, stBody> m_mapBody;
+    public:
+        void put(const QString& _url, const stBody& _stbody);
+        bool putCategory(const QString& _url, const int& _nCategory);
+        bool uploadData(QSqlDatabase &_db, const int& _nCompany, const QStringList& _order);
+        bool changeTable(QSqlDatabase &_db, const int& nCompany);
+        int getBodyNum(const QString& _url);
+        QString vecToString(const QVector<int>& _realbycategorynum);
+        QString vecToString(const QSet<int> &_realbycategorynum);
+        void setInitializer(SInitializer &initializer){ m_pSInitializer = &initializer; }
+        stBody* get(const QString& _url);
+        void clear();
+    };
+
+    class SReply
+    {
+    private:
+        //QList<stReply> m_listReply;
+        SInitializer *m_pSInitializer;
+        QMap<QString, QMap<int, stReply> > m_mapReply;
+    public:
+        void put(const QString& _url, const int& _order, const stReply& _streply);
+        bool putCategory(const QString &_url, const int &_order, int& _nCategory);
+        bool uploadData(QSqlDatabase &_db, const int& _nCompany, QStringList& _order);
+        bool changeTable(QSqlDatabase &_db, const int& _nCompany);
+        int getReplyNum(const QString &_url, const int& _order);
+        stReply* get(const QString& _url, const int& _order);
+        QMap<int, stReply>* get(const QString& _url);
+        QString vecToString(const QVector<int>& _realbycategorynum);
+        void setInitializer(SInitializer &initializer){ m_pSInitializer = &initializer; }
+        void clear();
+    };
+    class SId
+    {
+    private:
+        QMap<QString, stId> m_mapId;
+        SInitializer *m_pSInitializer;
+    public:
+        bool contains(const QString& _strKey);
+        void put(const QString& _strKey, const stId& _stid);
+        void put(const stId& _stid);
+        QString getIdKey(const QStringList& _strlist);
+        stId* get(const QString &_strKey);
+        bool changeTable(QSqlDatabase &_db, const int& _nCompany);
+        bool uploadData(QSqlDatabase &_db, const int& _nCompany);
+        void setInitializer(SInitializer &initializer){ m_pSInitializer = &initializer; }
+        void clear();
+    };
+    class SNickname
+    {
+    private:
+        QMap<QString, stNickname> m_mapNickname;
+        SInitializer *m_pSInitializer;
+    public:
+        //QString getNicknameKey(const QStringList& _strlist);
+        stNickname* get(const QString &_strKey);
+        bool changeTable(QSqlDatabase &_db, const int& _nCompany);
+        bool uploadData(QSqlDatabase &_db, const int& _nCompany);
+        void put(const QString& _strKey, const stNickname& _stnickname);
+        void put(const stNickname& _nickname);
+        bool contains(const QString& _strKey);
+        void setInitializer(SInitializer &initializer){ m_pSInitializer = &initializer; }
+        void clear();
+    };
+    class SCommunity
+    {
+    private:
+        QMap<QString, stCommunity> m_mapCommunity;
+        SInitializer *m_pSInitializer;
+    public:
+        QString getCommunityKey(const QStringList& _strlist);
+        stCommunity* get(const QString &_strKey);
+        bool changeTable(QSqlDatabase &_db, const int& _nCompany);
+        bool uploadData(QSqlDatabase &_db, const int& _nCompany);
+        void put(const QString& _strKey, const stCommunity& _stcommunity);
+        bool contains(const QString& _strKey);
+        void clear();
+        void setInitializer(SInitializer &initializer){ m_pSInitializer = &initializer; }
+    };
+    struct stBodyReplyCount
+    {
+        int m_nAllBodyCount;
+        int m_nAllReplyCount;
+        int m_nFilterBodyCount;
+        int m_nFilterReplyCount;
+        stBodyReplyCount():m_nAllBodyCount(0), m_nAllReplyCount(0), m_nFilterBodyCount(0), m_nFilterReplyCount(0){}
+    };
+    struct stDate
+    {
+        QString m_strMindate;
+        QString m_strMaxdate;
+        QString m_strLastupdate;
+        stDate():m_strMindate("2100-12-31 23:59:59"), m_strMaxdate("1900-01-01 00:00:00"), m_strLastupdate("1900-01-01 00:00:00"){}
+    };
+
+private:
+    SInitializer* m_pSInitializer;
+    QSet<QString> m_setFilteredUrl;
+
+    QStringList m_slOrderedBodyUrl;
+    QMap<QString, QMap<int, QStringList> > m_mapReply;
+    QMap<QString, QStringList> m_mapBody;
+    QMap<stProfileurlKey, QStringList*> m_mapProfile;
+
+
+    SBody m_SBody;
+    SReply m_SReply;
+    SCommunity m_SCommunity;
+    SId m_SId;
+    SNickname m_SNickname;
+    stBodyReplyCount m_stBodyReplyCount;
+    stDate m_stDate;
+
+public:
+    void setInitializer(SInitializer &initializer);
+    bool loadData(const int& _nDatagroupNumber);
+    bool uploadData(const int& _nCompany);
+    bool changeTable(const int& _nCompany);
+    bool makeTable();
+    void addRealUrl(const QString& _strUrl);
+    void copyData(QVector<QStringList> *_data);
+    const QMap<QString, QStringList>* getmapBody();
+    const QStringList* getmapBody(const stProfileurlKey& _stprofileurlkey);
+    const QMap<QString, QMap<int, QStringList> >* getmapReply();
+    const stBody* getstBody(const QString& _strUrl);
+    const stReply* getstReply(const QString& _strUrl, const int &_order);
+    const QMap<int, stReply>* getstReply(const QString& _strUrl);
+    int getstBodyNum(const QString& _strUrl);
+    int getstReplyNum(const QString& _strUrl, const int &_order);
+    const QStringList* getOrderedUrl();
+    void addRealBodyCategory(const QString& _strUrl, const int _nCategory);
+    void addRealReplyCategory(const QString& _strUrl, const int& _order, int _nCategory);
+    const stCommunity* getstCommunity(const QStringList& _sl);
+    const stBodyReplyCount* getCounts();
+    const stDate* getstDate();
+
+private:
+    void init();
+    void setloadQuery(QString _astrQuery[], int _nDatagroupNumber);
+    void makeProfile(const QStringList& _strList);
+};
+
+
+#endif // SDATAGROUP
+

FilterProcess/sdbmanager.cpp

@@ -0,0 +1,124 @@
+#include <QString>
+#include <QStringList>
+#include <QSqlDatabase>
+#include <QSqlQuery>
+#include <QSqlError>
+#include <QVariant>
+#include "sdbmanager.h"
+
+void SDBManager::addDatabase(const QString& _dbName,const QString& _host,const QString& _id, const QString& _pw, const QString& _db, const int& _port)
+{
+    QSqlDatabase db = QSqlDatabase::addDatabase("QMYSQL", _dbName);
+    db.setHostName(_host);
+    db.setUserName(_id);
+    db.setPassword(_pw);
+    db.setDatabaseName(_db);
+    db.setPort(_port);
+}
+
+
+void SDBManager::addDatabase(const QString& _dbName, const E_DATABASE& _eDatabase, const QString& _host, const QString& _id, const QString& _pw, const QString& _db, const int& _port)
+{
+    QSqlDatabase db = QSqlDatabase::addDatabase("QMYSQL", _dbName);
+    db.setHostName(_host);
+    db.setUserName(_id);
+    db.setPassword(_pw);
+    db.setDatabaseName(_db);
+    db.setPort(_port);
+    m_mapDBname.insert(_eDatabase, _dbName);
+}
+
+QSqlDatabase SDBManager::getDBConnection(const QString& _dbName) const
+{
+    return QSqlDatabase::database(_dbName);
+}
+
+QSqlDatabase SDBManager::getDBConnection(const E_DATABASE& _eDatabase) const
+{
+    return QSqlDatabase::database(m_mapDBname.value(_eDatabase));
+}
+
+bool SDBManager::open(const QString& _dbName)
+{
+    QSqlDatabase db = QSqlDatabase::database(_dbName);
+    return db.open();
+}
+
+bool SDBManager::open(const E_DATABASE& _eDatabase)
+{
+    QSqlDatabase db = QSqlDatabase::database(m_mapDBname.value(_eDatabase));
+    return db.open();
+}
+
+void SDBManager::close(const E_DATABASE& _eDatabase)
+{
+    QSqlDatabase db = QSqlDatabase::database(m_mapDBname.value(_eDatabase));
+    db.close();
+}
+
+void SDBManager::close(const QString& _dbName)
+{
+    QSqlDatabase db = QSqlDatabase::database(_dbName);
+    db.close();
+}
+
+void SDBManager::close()
+{
+    QStringList strlist = QSqlDatabase::connectionNames();
+    foreach (const QString& str, strlist)
+        QSqlDatabase::database(str).close();
+}
+
+QSqlQuery SDBManager::sqlQuery(const E_DATABASE& _eDatabase)
+{
+    QSqlQuery query(QSqlDatabase::database(m_mapDBname.value(_eDatabase)));
+    return query;
+}
+
+QSqlQuery SDBManager::sqlQuery(const QString& _dbName)
+{
+    QSqlQuery query(QSqlDatabase::database(_dbName));
+    return query;
+}
+
+bool SDBManager::reOpen(const QString& _dbName)
+{
+    close(_dbName);
+    return open(_dbName);
+}
+
+bool SDBManager::reOpen(const E_DATABASE& _eDatabase)
+{
+    close(_eDatabase);
+    return open(_eDatabase);
+}
+
+bool SDBManager::isConnectionError(const QSqlError& _error)
+{
+    if(_error.number() == 2013 || _error.number() == 2006 || _error.number() == 10054)
+        return true;
+    return false;
+}
+
+SDBManager::~SDBManager()
+{
+    QStringList strlist = QSqlDatabase::connectionNames();
+    foreach (const QString& str, strlist)
+    {
+        QSqlDatabase db = QSqlDatabase::database(str);
+        if(db.isOpen())
+            db.close();
+    }
+    foreach (const QString& str, strlist)
+        QSqlDatabase::removeDatabase(str);
+}
+
+QSqlDatabase SDBManager::operator[](const QString& _dbName) const
+{
+    return QSqlDatabase::database(_dbName);
+}
+
+QSqlDatabase SDBManager::operator[](const E_DATABASE& _eDatabase) const
+{
+    return QSqlDatabase::database(m_mapDBname.value(_eDatabase));
+}

FilterProcess/sdbmanager.h

@@ -0,0 +1,37 @@
+#ifndef SDBMANAGER
+#define SDBMANAGER
+#include <QMap>
+class QSqlDatabase;
+class QSqlQuery;
+class QString;
+class QStringList;
+class QSqlError;
+
+class SDBManager
+{
+public:
+    enum E_DATABASE{ E_DATABASE_DATA, E_DATABASE_WEB };
+    QSqlDatabase getDBConnection(const QString& _dbName) const;
+    QSqlDatabase getDBConnection(const E_DATABASE& _eDatabase) const;
+    bool open(const QString& _dbName);
+    bool open(const E_DATABASE& _eDatabase);
+    void close(const QString& _dbName);
+    void close(const E_DATABASE& _eDatabase);
+    void close();
+    void addDatabase(const QString& _dbName, const QString& _host, const QString& _id, const QString& _pw, const QString& _db, const int& _port = 3306);
+    void addDatabase(const QString& _dbName, const E_DATABASE& _eDatabase, const QString& _host, const QString& _id, const QString& _pw, const QString& _db, const int& _port = 3306);
+    QSqlQuery sqlQuery(const QString& _dbName);
+    QSqlQuery sqlQuery(const E_DATABASE& _eDatabase);
+    bool reOpen(const QString& _dbName);
+    bool reOpen(const E_DATABASE& _eDatabase);
+    bool isConnectionError(const QSqlError& _error);
+    QSqlDatabase operator[](const QString& _dbName) const;
+    QSqlDatabase operator[](const E_DATABASE& _eDatabase) const;
+    virtual ~SDBManager();
+private:
+    QMap<E_DATABASE, QString> m_mapDBname;
+};
+
+
+#endif // SDBMANAGER
+

FilterProcess/sfilteralgorithm.cpp

@@ -0,0 +1,243 @@
+#include <QDate>
+#include <QMap>
+#include <QString>
+#include "sfilteralgorithm.h"
+#include "../Json/sjson.h"
+#include <QDebug>
+
+void FilterSearch(QVector<QStringList> *m_data, bool *m_bDataFlag, QString _strJson);
+void FilterCounter(QVector<QStringList> *m_data, bool *m_bDataFlag, QString _strJson);
+void FilterReplace(QVector<QStringList> *m_data, bool *m_bDataFlag, QString _strJson);
+void FilterDate(QVector<QStringList> *m_data, bool *m_bDataFlag, QString _strJson, int _nDateColumn);
+void FilterLength(QVector<QStringList> *m_data, bool *m_bDataFlag, QString _strJson);
+
+void SFilterAlgorithm::FilterDate(QVector<QStringList> *m_data, bool *m_bDataFlag, QString _strJson, int _nDateColumn)
+{
+    SJson json;
+    int nSelect = json.Get(_strJson,"Article").toInt() - 1;
+    if (nSelect < 0) return;
+    m_bDataFlag[nSelect] = true;
+    QVector <QStringList> copyData;
+    QDate dateStart = QDate::fromString(json.Get(_strJson,"Start"),"yyyy-MM-dd");
+    QDate dateEnd = QDate::fromString(json.Get(_strJson,"End"),"yyyy-MM-dd");
+    foreach(const QStringList& strList , m_data[nSelect])
+    {
+        bool bFlag = false;
+        QString strTime = strList.at(_nDateColumn).trimmed();
+        if (strTime.size() >= 10)
+        {
+            QChar ch = strTime.at(4);
+            QString strFormat = QString("yyyy")+ch+QString("MM")+ch+QString("dd");
+            QDate date = QDate::fromString(strTime.left(10),strFormat);
+            if (dateStart <= date && dateEnd >= date)
+                bFlag = true;
+        }
+        if (bFlag)
+            copyData.push_back(strList);
+    }
+    m_data[nSelect].clear();
+    m_data[nSelect] = copyData;
+}
+
+void SFilterAlgorithm::FilterLength(QVector<QStringList> *m_data, bool *m_bDataFlag, QString _strJson)
+{
+    SJson json;
+    int nSelect = json.Get(_strJson,"Article").toInt() - 1;
+    if (nSelect < 0) return;
+    m_bDataFlag[nSelect] = true;
+
+    int nCatalog = json.GetNumber(_strJson,"Category");
+    int nComp = json.GetNumber(_strJson,"Comp");
+    int nFlag = json.GetNumber(_strJson,"InsDel");
+    int nLength = json.Get(_strJson,"String").toInt();
+
+    QVector <QStringList> copyData;
+    foreach(const QStringList& strList , m_data[nSelect])
+    {
+        bool bFlag = false;
+        int nCurrentLength = strList.at(nCatalog).trimmed().length();
+        switch(nComp)
+        {
+        case E_LENGTH_COMP_GREATER:
+            if (nCurrentLength > nLength)
+                bFlag = true;
+            break;
+        case E_LENGTH_COMP_LESS:
+            if (nCurrentLength < nLength)
+                bFlag = true;
+            break;
+        case E_LENGTH_COMP_EQUAL:
+            if (nCurrentLength == nLength)
+                bFlag = true;
+            break;
+        }
+        if (nFlag == 1) bFlag = !bFlag;
+        if (bFlag)
+            copyData.push_back(strList);
+    }
+    m_data[nSelect].clear();
+    m_data[nSelect] = copyData;
+}
+
+void SFilterAlgorithm::FilterCounter(QVector<QStringList> *m_data, bool *m_bDataFlag, QString _strJson)
+{
+    SJson json;
+    int nSelect = json.Get(_strJson,"Article").toInt() - 1;
+    if (nSelect < 0) return;
+    m_bDataFlag[nSelect] = true;
+
+    int nCatalog = json.GetNumber(_strJson,"Category");
+    int nComp = json.GetNumber(_strJson,"Comp");
+    int nFlag = json.GetNumber(_strJson,"InsDel");
+    int nCounter = json.Get(_strJson,"String").toInt();
+
+    QMap <QString, int> mapData, mapDataresult;
+    foreach(const QStringList& strList , m_data[nSelect])
+    {
+        QString str = strList.at(nCatalog).trimmed();
+        if(mapData.contains(str))
+            mapData[str]++;
+        else
+            mapData.insert(str, 1);
+    }
+
+    for(QMap <QString, int>::iterator iterPos = mapData.begin(); iterPos != mapData.end(); iterPos++)
+    {
+        bool bFlag = false;
+        switch(nComp)
+        {
+        case E_LENGTH_COMP_GREATER:
+            if (iterPos.value() > nCounter)
+                bFlag = true;
+            break;
+        case E_LENGTH_COMP_LESS:
+            if (iterPos.value() < nCounter)
+                bFlag = true;
+            break;
+        case E_LENGTH_COMP_EQUAL:
+            if (iterPos.value() == nCounter)
+                bFlag = true;
+            break;
+        }
+        if (nFlag == 1) bFlag = !bFlag;
+        if (bFlag)
+            mapDataresult.insert(iterPos.key(), iterPos.value());
+    }
+
+    mapData.clear();
+
+    QVector <QStringList> copyData;
+    foreach(const QStringList& strList , m_data[nSelect])
+    {
+        QString str = strList.at(nCatalog).trimmed();
+        if(mapDataresult.contains(str))
+            copyData.push_back(strList);
+    }
+    m_data[nSelect].clear();
+    m_data[nSelect] = copyData;
+}
+
+void SFilterAlgorithm::FilterReplace(QVector<QStringList> *m_data, bool *m_bDataFlag, QString _strJson)
+{
+    SJson json;
+    int nSelect = json.Get(_strJson,"Article").toInt() - 1;
+    if (nSelect < 0) return;
+    m_bDataFlag[nSelect] = true;
+
+    int nCatalog = json.GetNumber(_strJson,"Category");
+    QString strFind = json.Get(_strJson,"String_Find");
+    QString strReplace = json.Get(_strJson,"String_Replace");
+
+    bool bFlag = false;
+    QStringList strListKeyword;
+    if (json.GetNumber(_strJson,"Find") == E_REPLACE_SPACE)
+    {
+        bFlag = true;
+        strListKeyword = strFind.split(" ");
+    }
+
+    for (int i = 0 ; i < m_data[nSelect].size(); i++)
+    {
+        if (bFlag)
+        {
+            foreach(const QString& str,strListKeyword)
+            {
+                m_data[nSelect][i][nCatalog] = m_data[nSelect][i][nCatalog].replace(str,strReplace);
+            }
+        }
+        else
+            m_data[nSelect][i][nCatalog] = m_data[nSelect][i][nCatalog].replace(strFind,strReplace);
+    }
+}
+
+void SFilterAlgorithm::FilterSearch(QVector<QStringList> *m_data, bool *m_bDataFlag, QString _strJson)
+{
+    SJson json;
+    int nSelect = json.Get(_strJson,"Article").toInt() - 1;
+    if (nSelect < 0) return;
+    m_bDataFlag[nSelect] = true;
+    {
+        SKeyword stKeyword;
+        stKeyword.m_nCatalog = json.GetNumber(_strJson,"Category");
+        stKeyword.m_nKeyword = json.GetNumber(_strJson,"Keyword");
+        stKeyword.m_strListKeyword = json.Get(_strJson,"String").split(" ", QString::SkipEmptyParts);
+        if (json.GetNumber(_strJson,"Method") == 1)
+        {
+            for (int i = 0 ; i < stKeyword.m_strListKeyword.size(); i++ )
+                stKeyword.m_strListKeyword[i] = " " + stKeyword.m_strListKeyword[i] + " ";
+        }
+        m_vecKeyword.push_back(stKeyword);
+    }
+    if (json.GetBool(_strJson,"Last")) //
+    {
+        QVector <QStringList> copyData;
+
+        foreach(const QStringList& strList , m_data[nSelect])
+        {
+            bool bFlag = false;
+            foreach(const SKeyword& stKeyword,m_vecKeyword)
+            {
+                QString strData = strList.at(stKeyword.m_nCatalog);
+                switch(stKeyword.m_nKeyword)
+                {
+                    case E_SEARCH_KEYWORD_OR:
+                    {
+                        foreach(const QString& strKey , stKeyword.m_strListKeyword)
+                            if (strData.contains(strKey)){bFlag = true;break;}
+                        break;
+                    }
+                    case E_SEARCH_KEYWORD_AND:
+                    {
+                        int nKeyCount = 0;
+                        foreach(const QString& strKey , stKeyword.m_strListKeyword)
+                            if (strData.contains(strKey)) nKeyCount++;
+                        if (nKeyCount == stKeyword.m_strListKeyword.size())
+                            bFlag = true;
+                        break;
+                    }
+                    case E_SEARCH_KEYWORD_CELL_DELETE_OR:
+                    {
+                        bFlag = true;
+                        foreach(const QString& strKey , stKeyword.m_strListKeyword)
+                            if (strData.contains(strKey)){bFlag = false;break;}
+                        break;
+                    }
+                    case E_SEARCH_KEYWORD_CELL_DELETE_AND:
+                    {
+                        bFlag = true;
+                        int nCount = 0;
+                        foreach(const QString& strKey , stKeyword.m_strListKeyword)
+                            if (strData.contains(strKey)){nCount++;}
+                        if (nCount == stKeyword.m_strListKeyword.size())
+                            bFlag = false;
+                        break;
+                    }
+                }
+            }
+            if (bFlag) copyData.push_back(strList);
+        }
+        m_data[nSelect].clear();
+        m_data[nSelect] = copyData;
+        m_vecKeyword.clear();
+    }
+}

FilterProcess/sfilteralgorithm.h

@@ -0,0 +1,23 @@
+#ifndef SFILTERALGORITHM
+#define SFILTERALGORITHM
+#include <QVector>
+#include "../common.h"
+class QString;
+class QStringList;
+class SFilterAlgorithm
+{
+private:
+    QVector <SKeyword> m_vecKeyword;
+public:
+    void FilterSearch(QVector<QStringList> *m_data, bool *m_bDataFlag, QString _strJson);
+    void FilterCounter(QVector<QStringList> *m_data, bool *m_bDataFlag, QString _strJson);
+    void FilterReplace(QVector<QStringList> *m_data, bool *m_bDataFlag, QString _strJson);
+    void FilterDate(QVector<QStringList> *m_data, bool *m_bDataFlag, QString _strJson, int _nDateColumn);
+    void FilterLength(QVector<QStringList> *m_data, bool *m_bDataFlag, QString _strJson);
+
+};
+
+
+
+#endif // SFILTERALGORITHM
+

FilterProcess/sfilterprocess.h

@@ -1,310 +1,40 @@
-#ifndef SFILTERPROCESS_H
+#ifndef SFILTERPROCESS
-#define SFILTERPROCESS_H
+#define SFILTERPROCESS
-
+#include "sinitializer.h"
+#include "sdatagroup.h"
+#include "sconsumer.h"
+#include "sinfluencer.h"
+#include "sspammer.h"
+#include "spowercafe.h"
 #include <QObject>
-#include <QObject>
+class QString;
-#include <QThread>
-#include <QSqlDatabase>
-#include <QMap>
-#include <QListWidget>
-#include <QSqlDatabase>
-#include <QVector>
-#include <QDateTime>
-#include <iostream>
 
-#include "./../common.h"
+class SFilterProcess:public QObject
-
-using namespace std;
-
-struct SReply
-{
-    QStringList m_strlist;
-    QDate m_date;
-    bool m_bSelect;
-    int m_nOrder;
-    QVector <int> m_vecCategory;
-};
-
-struct SBody
-{
-    int m_nNum;
-    QStringList m_strlist;
-    bool m_bSelect;
-    bool m_bReplySelect;
-    QDateTime m_dtLast;
-    QDate m_date;
-    QMap <int,SReply> m_vecReply;
-    QVector <int> m_vecCategory;
-};
-
-struct SMap
-{
-    int m_nBody;
-    int m_nCategory;
-    int m_nRealIn;
-    QString m_strURL;
-};
-
-struct SInfluenceCount
-{
-    int m_ncBody;
-    int m_ncReply;
-    double m_dinfulrence;
-    int m_nID;
-    int m_nNickname;
-    int m_nCommunity;
-    QString m_strID;
-    QString m_strOrder;
-    QStringList m_strlistData;
-    SInfluenceCount()
-    {
-        m_nNickname = 0;
-        m_nCommunity = 0;
-        m_nID = 0;
-    }
-};
-
-struct SPowerCafeCount
-{
-    QString m_strCafeID;
-    QString m_strCommunityURL;
-    QStringList m_strlistData;
-    int m_nCommunityID;
-    int m_ncBodyAll;
-    int m_ncReplyAll;
-    int m_ncAll;
-    int m_ncBodyReal;
-    int m_ncReplyReal;
-    int m_ncAllReal;
-    int m_ncUserReal;
-    int m_ncUserAll;
-    QMap <QString,bool> m_mapUser;
-    SPowerCafeCount()
-    {
-        m_ncBodyAll = 0;
-        m_ncReplyAll = 0;
-        m_ncAll = 0;
-        m_ncBodyReal = 0;
-        m_ncReplyReal = 0;
-        m_ncAllReal = 0;
-        m_ncUserReal = 0;
-        m_ncUserAll = 0;
-    }
-};
-
-struct SBuzzyArticle
-{
-    QMap <QDate,int> m_mapCount;
-};
-
-#define D_ARTICLE_MAX 3
-
-struct SBuzzyCount
-{
-    int m_nCategory;
-    int m_anCount[D_ARTICLE_MAX];
-};
-
-struct SId
-{
-    int     m_nNum;
-    int     m_nPlatfromName;
-    int     m_nCommunity;
-    QString m_strID;
-    SId()
-    {
-        m_nNum = 0;
-        m_nCommunity = 0;
-        m_nPlatfromName = 1;
-        m_strID = "(none)";
-    }
-};
-
-struct SCommunity
-{
-    int     m_nNum;
-    int     m_nPlatformname;
-    int     m_nPlatformform;
-    QString m_strTitle;
-    QString m_strUrl;
-    QString m_strID;
-    QString m_strExid;
-
-    SCommunity()
-    {
-        m_nNum = 0;
-        m_nPlatformname = 1;
-        m_nPlatformform = 1;
-        m_strTitle = "(none)";
-        m_strUrl = " ";
-        m_strID = " ";
-        m_strExid = " ";
-    }
-};
-
-struct SNickname
-{
-    int     m_nNum;
-    int     m_nID;
-    QString m_strNickname;
-    SNickname()
-    {
-        m_nID = 0;
-    }
-};
-
-struct SNaverBlogProfile
-{
-    QDateTime m_date;
-    QString m_strURL;
-};
-
-class SFilterProcess : public QObject
 {
     Q_OBJECT
+private:
+    SInitializer m_SInitializer;
+    SDatagroup m_SDatagroup;
+    SConsumer m_SConsumer;
+    SInfluencer m_SInfluencer;
+    SSpammer m_SSpammer;
+    SPowercafe m_SPowercafe;
+    SConsumerMarketer m_SConsumerMarketer;
+    SConsumerCheckList m_SConsumerCheckList;
+    int m_nCompany;
 public:
-    enum E_COLUMN
+    enum E_SERVICE
     {
-        E_COLUMN_DATABASE=0,
+        E_SERVICE_INFLUENCER = 1,
-        E_COLUMN_NAME,
+        E_SERVICE_CONSUMER,
-        E_COLUMN_DATE,
+        E_SERVICE_SPAMMER,
-        E_COLUMN_COUNT,
+        E_SERVICE_POWERCAFE
     };
-
+    SFilterProcess(QObject *parent = 0):QObject(parent), m_nCompany(-1){}
-    enum E_ARTICLE
+    bool init(QString _strFilterProcessGroupID, QString _strFilterProcessGroupName);
-    {
+    bool run();
-        E_ARTICLE_BODY = 0,
+    int getCompanyNum();
-        E_ARTICLE_REPLY,
-        E_ARTICLE_MAX,
-    };
-
-    enum E_DATA
-    {
-        E_DATA_platform_title = 0,
-        E_DATA_article_form,
-        E_DATA_article_parent,
-        E_DATA_article_id,
-        E_DATA_article_nickname,
-        E_DATA_article_title,
-        E_DATA_article_data,
-        E_DATA_article_url,
-        E_DATA_article_hit,
-        E_DATA_article_date,
-        E_DATA_article_order,
-        E_DATA_platform_id,
-        E_DATA_platform_name,
-        E_DATA_platform_form,
-        E_DATA_reply_url,
-        E_DATA_keyword_id,
-        E_DATA_article_profileurl,
-        E_DATA_article_profile,
-        E_DATA_etc,
-        E_DATA_MAX,
-    };
-
-    enum E_SPAMER
-    {
-        E_SPAMER_BODY_COUNT_CUT = 0,
-        E_SPAMER_BODY_COUNT_RATIO,
-        E_SPAMER_REPLY_COUNT_CUT,
-        E_SPAMER_REPLY_COUNT_RATIO,
-        E_SPAMER_NICK_COUNT_CUT,
-        E_SPAMER_NICK_COUNT_RATIO,
-        E_SPAMER_MAX
-    };
-
-    struct SBuzzy
-    {
-        SBuzzyArticle m_astArticle[E_ARTICLE_MAX];
-        int m_nArticle;
-        int m_nCategory;
-    };
-    SFilterProcess();
-    ~SFilterProcess();
-    void run(QString _strFindID,QString _strFilterGroupName);
-    bool ReloadSetup();
-private:
-    QSqlDatabase m_db;
-    int m_anData[E_DATA_MAX];
-    int m_nDateColumn;
-    int m_nUrlColumn;
-    int m_nOrderColumn;
-    QVector <QStringList> m_data[E_ARTICLE_MAX],m_dataAll[E_ARTICLE_MAX];
-    bool m_bDataFlag[E_ARTICLE_MAX],m_bDataFlagAll[E_ARTICLE_MAX];
-    QSet <QString> m_setDataAll[E_ARTICLE_MAX];
-    QStringList m_listDataBaseColumn;
-    QMap <QString,SBody> m_mapData;
-    QVector <SMap> m_vecMap;
-    QStringList m_strlistOrder;
-    QVector <SInfluenceCount> m_vecInfluence;
-    QVector <SBuzzy> m_vecBuzzy;
-    QMap <QString,SId> m_mapID;
-    QMap <QString,SCommunity> m_mapCommunity;
-    QMap <QString,SNickname> m_mapNickname;
-    QMap <QString,int> m_mapPlatformform;
-    QMap <QString,int> m_mapPlatformname;
-    QMap <QString,SNaverBlogProfile> m_mapNaverBlogProfile;
-    QString m_strFilterGroupName;
-
-    const int C_MAP_REAL_BODY;
-    const int C_MAP_REAL_REPLY;
-
-    QString m_strWebDataBaseHost;
-    QString m_strWebDataBaseUser;
-    QString m_strWebDataBasePass;
-    QString m_strWebDataBaseName;
-
-    double m_adSpammer[E_SPAMER_MAX];
-
-    int m_nCutDays;
-    QString m_strStartDay;
-    QString m_strEndDay;
-
-    QVector <SKeyword> m_vecKeyword;
-    QMap <QString,int> m_mapReply;
-
-private:
-    bool LockTable(QString _strTable);
-    void UnLockTables();
-
-    void DataFilter(QString _strFilterGroupID);
-    void DataCategoryMake(QString _strFilter,int _nCategory);
-    void DataPut(QString _strCompanyNum);
-    void DataLoad(QString _strDataNum);
-    void DataInfluenceBuzzCount(QString _strCompanyNum);
-    void DataInfluenceCount(QString _strFilter,QString _strCompanyNum);
-    void DataSpammersCount(QString _strFilter,QString _strCompanyNum);
-    void DataPowerCafeCount(QString _strFilter,QString _strCompanyNum);
-    void DataConsumerSupervisionCount(QString _strCompanyNum);    
-    QString GetVectorToString(QVector <int> _vecCategory,QString _strDelimiter);
-    void DataMake(int _nCategory,QVector <QStringList> *_data, bool *_bDataFlag);
-
-    void MakeBuzzy(int _nCategory,QVector <QStringList> *_data, bool *_bDataFlag);
-    void MakeBuzzyAll();
-
-    void DataAdd();
-    void DataCategoryAllMake(QString _strCompany);
-
-    QString SqlString(QString _str);
-    bool RenameTable(QString _strOld, QString _strNew , QString _strTmp);
-    void FilterDate(QString strJson);
-    void FilterSerach(QString strJson);
-    void FilterLength(QString strJson);
-    void FilterReplace(QString strJson);
-    void FilterCounter(QString _strJson);
-
-    bool ReloadColumn();    
-    void ReloadData();
-    QString SeqDelString(QString _strData,QChar _chChar,int _nMax);
-    QString MakeInfluencerrankQuery(const SInfluenceCount &_stIn,int _nRank,QString _strSubject,QString _strCompanyNum);
-    QVariant GetWebData(QString _strTable,QString _strColumn,int _nNum);
-    QVariant GetWebData(QString _strTable,QString _strColumn,QString _strWhere);
-    inline QString GetCommunityKey(const QStringList _strList);
-    void InsertLog(QString _strMsg);
-    void UpdateDBInfoState(QSqlDatabase &_db,QString _strCompanyNum,QString _strStatus);
-public slots:
-signals:
-    void finished();
 };
 
-#endif // SFILTERPROCESS_H
+#endif // SFILTERPROCESS
+

FilterProcess/shttpsender.cpp

@@ -0,0 +1,104 @@
+#include "shttpsender.h"
+#include <QString>
+#include <QSql>
+#include <iostream>
+#include <QTimer>
+SHttpSender::SHttpSender(QObject * obj) : QObject(obj), socket(new QTcpSocket(this))
+{
+    QSqlDatabase db = QSqlDatabase::database("WEB");
+    QString hostName = db.hostName();
+
+    if (hostName == "192.168.0.82")
+    {
+        addr = hostName;
+        port = 8080;
+    }
+    else if (hostName == "192.168.0.30")
+    {
+        addr = "big-bird1.co.kr";
+        port = 80;
+    }
+    else if (hostName == "182.162.171.147")
+    {
+        addr = "big-bird.co.kr";
+        port = 80;
+    }
+    else
+    {
+        /*
+        addr = "big-bird.co.kr";
+        port = 80;
+        */
+    }
+    connect(socket, SIGNAL(disconnected()), this, SLOT(DisConnected()));
+    connect(socket, SIGNAL(readyRead()), this, SLOT(ReadData()));
+    connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(error(QAbstractSocket::SocketError)));
+    //connect(socket, &QTcpSocket::hostFound, [](){ std::cout << "founded"; });
+    //connect(socket, &QTcpSocket::connected, [](){ std::cout << "connected"; });
+    socket->connectToHost(QHostAddress(addr), port);
+    socket->waitForConnected(2000);
+}
+
+SHttpSender::~SHttpSender()
+{
+    socket->close();
+    delete socket;
+}
+
+void SHttpSender::SendData(int _company_num)
+{
+    QString strPort = "";
+    if (port != 80)
+        strPort = ":" + QString::number(static_cast<unsigned int>(port));
+
+    //std::cout << addr.toStdString() << strPort.toStdString();
+
+    QString data;
+    if (port != 80)
+        data = "GET /concepters/filter_actionAtDataUpdateComplete.do?company_num=" + QString::number(_company_num) + " HTTP/1.1\r\n";
+    else
+        data = "GET /filter_actionAtDataUpdateComplete.do?company_num=" + QString::number(_company_num) + " HTTP/1.1\r\n";
+
+    data += "Host: " + addr + strPort + "\r\n"
+            "Connection: keep-alive\r\n"
+            "Cache-Control: max-age=0\r\n"
+            "Upgrade-Insecure-Requests: 1\r\n"
+            "User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.71 Safari/537.36\r\n"
+            "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8\r\n"
+            "Accept-Encoding: gzip, deflate, sdch\r\n"
+            "Accept-Language: ko-KR,ko;q=0.8,en-US;q=0.6,en;q=0.4\r\n\r\n\r\n";
+
+    if(!data.isEmpty())
+    {
+        socket->write(QString(data + "\n").toUtf8());
+        //std::cout << data.toStdString();
+        //std::cout << "sent";
+    }
+    QTimer::singleShot(5000, this, SLOT(DisConnected()));
+}
+
+void SHttpSender::ReadData()
+{
+    exit(0);
+    /*
+    QString m_str;
+    while(socket->canReadLine())
+    {
+        QString str = QString::fromUtf8(socket->readLine()).trimmed();
+        m_str += str;
+        std::cout << str.toStdString();
+    }
+    //exit(0);
+    */
+}
+
+void SHttpSender::error(QAbstractSocket::SocketError error)
+{
+    exit(0);
+}
+
+void SHttpSender::DisConnected()
+{
+    exit(0);
+}
+

FilterProcess/shttpsender.h

@@ -0,0 +1,25 @@
+#ifndef SHTTPSENDER_H
+#define SHTTPSENDER_H
+#include <QObject>
+#include <QtNetwork>
+#include <QtNetwork/QTcpSocket>
+#include <QSqlDatabase>
+class SHttpSender : public QObject
+{
+    Q_OBJECT
+public:
+    SHttpSender(QObject * obj = 0);
+    void SendData(int _company_num);
+    virtual ~SHttpSender();
+private slots:
+    void ReadData();
+    void DisConnected();
+    void error(QAbstractSocket::SocketError error);
+
+private:
+    QTcpSocket *socket;
+    quint16 port;
+    QString addr;
+};
+
+#endif // SHTTPSENDER_H

FilterProcess/sinfluencer.h

@@ -0,0 +1,257 @@
+#ifndef SINFLUENCER
+#define SINFLUENCER
+#include "sservice.h"
+#include "sfilteralgorithm.h"
+#include "sinitializer.h"
+#include <QVector>
+class QString;
+class QStringList;
+class SInfluencer:public SService
+{
+public:
+    struct stReal
+    {
+        QSet<QString> m_setRealAllUrl;
+        QSet<QString> m_setRealBodyUrl;
+        QMap<QString, int> m_mapRealReplyUniqueUrl; //multiple
+    };
+    struct stInfluencer
+    {
+        int id_num;
+        int nickname_num;
+        int community_num;
+        int category_num;
+        QString id_id;
+        QString profile;
+        QString profileurl;
+        int bodycount;
+        int replycount;
+        double influencervalue;
+        int rank;
+        QString community_title;
+        QString community_url;
+        QString community_id;
+        QString nickname_nickname;
+        QString nickname_exnickname;
+        QString platformname_name;
+        int platformname_num;
+
+        stInfluencer():id_num(0),nickname_num(0),community_num(0),category_num(0),bodycount(0),replycount(0),rank(0),influencervalue(0.0),platformname_num(0){}
+
+    };
+    struct stStatsInfBloggerRank
+    {
+        QString id_id;
+        QString nickname_nickname;
+        int bodycount;
+        int replycount;
+        double influencevalue;
+        QString subject;
+        int company_num;
+        int rank;
+        stStatsInfBloggerRank():bodycount(0),replycount(0),rank(0),influencevalue(0.0){}
+        stStatsInfBloggerRank(const QString &_id_id, const QString &_nickname_nickname):id_id(_id_id),nickname_nickname(_nickname_nickname),
+            bodycount(0), replycount(0), rank(0), influencevalue(0.0) {}
+    };
+
+    struct stStatsInfBloggerBuzzbyday
+    {
+        QString date;
+        int formateddate;
+        int idcount;
+        int bodycount;
+        int replycount;
+        int company_num;
+        stStatsInfBloggerBuzzbyday():formateddate(0), idcount(0), bodycount(0), replycount(0), company_num(0){}
+    };
+
+    struct stBodyInfluencerMap
+    {
+        int num;
+        int body_num;
+        int id_num;
+        int category_num;
+        int realin;
+        int community_num;
+        QString date;
+        stBodyInfluencerMap():num(0),body_num(0), id_num(0), category_num(0), realin(0), community_num(0){}
+    };
+    struct stReplyInfluencerMap
+    {
+        int num;
+        int reply_num;
+        int body_num;
+        int id_num;
+        int category_num;
+        int realin;
+        int community_num;
+        QString body_date;
+        stReplyInfluencerMap():num(0),reply_num(0),body_num(0),id_num(0),category_num(0),realin(0),community_num(0){}
+    };
+
+    class SReplyInfluencerMap
+    {
+    private:
+        SInitializer *m_pSInitializer;
+        QList<stReplyInfluencerMap> m_listMap;
+    public:
+        void setInitiaizer(SInitializer &_initializer){ m_pSInitializer = &_initializer; }
+        void clear(){ m_listMap.clear(); }
+        void makeTable(SDatagroup &_datagroup, const QMap<int, stReal>& _mapCategory);
+        bool uploadData(QSqlDatabase &_db, const int &_nCompany);
+        bool changeTable(QSqlDatabase &_db, const int &_nCompany);
+    };
+
+    class STInfluencer
+    {
+    private:
+        SInitializer *m_pSInitializer;
+        QList<stInfluencer> m_listMap;
+    public:
+        void setInitiaizer(SInitializer &_initializer){ m_pSInitializer = &_initializer; }
+        void makeTable(SDatagroup &_datagroup, const QMap<int, stReal>& _mapCategory);
+        bool uploadData(QSqlDatabase &_db, const int &_nCompany);
+        bool changeTable(QSqlDatabase &_db, const int &_nCompany);
+        void clear(){ m_listMap.clear(); }
+    };
+
+    class SStatsInfBloggerRank
+    {
+    private:
+        SInitializer *m_pSInitializer;
+        QList<stStatsInfBloggerRank> m_listMap;
+    public:
+        void setInitiaizer(SInitializer &_initializer){ m_pSInitializer = &_initializer; }
+        void clear(){ m_listMap.clear(); }
+        void makeTable(SDatagroup &_datagroup, const QMap<int, stReal>& _mapCategory);
+        bool uploadData(QSqlDatabase &_db, const int &_nCompany);
+    };
+
+    class SStatsInfBloggerBuzzbyday
+    {
+    private:
+        SInitializer *m_pSInitializer;
+        QList<stStatsInfBloggerBuzzbyday> m_listMap;
+    public:
+        void setInitiaizer(SInitializer &_initializer){ m_pSInitializer = &_initializer; }
+        void clear(){ m_listMap.clear(); }
+        void makeTable(SDatagroup &_datagroup, const QMap<int, stReal>& _mapCategory);
+        bool uploadData(QSqlDatabase &_db, const int &_nCompany);
+    };
+
+    class SBodyInfluencerMap
+    {
+    private:
+        SInitializer *m_pSInitializer;
+        QList<stBodyInfluencerMap> m_listMap;
+    public:
+        void setInitiaizer(SInitializer &_initializer){ m_pSInitializer = &_initializer; }
+        void clear(){ m_listMap.clear(); }
+        void makeTable(SDatagroup &_datagroup, const QMap<int, stReal>& _mapCategory);
+        bool uploadData(QSqlDatabase &_db, const int &_nCompany);
+        bool changeTable(QSqlDatabase &_db, const int &_nCompany);
+    };
+
+
+    struct stStatsJson
+    {
+        int company_num;
+        int servicenum;
+        QString title;
+        QString subtitle;
+        int platformname_num;
+        QString jdata;
+        int category_num;
+        stStatsJson():company_num(0), servicenum(2), platformname_num(1), category_num(0){}
+    };
+
+    class SStatsJson
+    {
+    private:
+        SInitializer *m_pSInitializer;
+        QList<stStatsJson> m_listMap;
+    public:
+        void setInitiaizer(SInitializer &_SInitializer) { m_pSInitializer = &_SInitializer; }
+        void makeTable(SDatagroup &_datagroup, const QMap<int, stReal>& _mapCategory);
+        bool uploadData(QSqlDatabase& _db, const int &_nCompany);
+        void clear(){ m_listMap.clear(); }
+    };
+
+    struct isGreaterInfluencerValue
+    {
+        bool operator()(const stInfluencer& first,  const stInfluencer& second)
+        {
+            if (first.influencervalue > second.influencervalue)
+                return true;
+            else if (first.influencervalue == second.influencervalue)
+                return first.bodycount > second.bodycount;
+            else
+                return false;
+            //return first.influencervalue > second.influencervalue;
+        }
+        bool operator()(const stStatsInfBloggerRank& first, const stStatsInfBloggerRank& second)
+        {
+            if (first.influencevalue > second.influencevalue)
+                return true;
+            else if (first.influencevalue == second.influencevalue)
+                return first.bodycount > second.bodycount;
+            else
+                return false;
+            //return first.influencevalue > second.influencevalue;
+        }
+    };
+
+    struct isGreaterBodyCount
+    {
+        bool operator()(const stStatsInfBloggerRank& first, const stStatsInfBloggerRank& second)
+        {
+            return first.bodycount > second.bodycount;
+        }
+        bool operator()(const stInfluencer& first,  const stInfluencer& second)
+        {
+            return first.bodycount > second.bodycount;
+        }
+    };
+
+    struct isGreaterReplyCount
+    {
+        bool operator()(const stStatsInfBloggerRank& first, const stStatsInfBloggerRank& second)
+        {
+            return first.replycount > second.replycount;
+        }
+        bool operator()(const stInfluencer& first,  const stInfluencer& second)
+        {
+            return first.replycount > second.replycount;
+        }
+    };
+    struct stInfluenceBuzz
+    {
+        int bodycount;
+        int replycount;
+        QSet<QString> idcount;
+        stInfluenceBuzz():bodycount(0), replycount(0) {}
+    };
+
+private:
+    SFilterAlgorithm m_SFilterAlgorithm;
+    QMap<int, stReal> m_mapCategory;
+    SBodyInfluencerMap m_SBodyInfluencerMap;
+    SReplyInfluencerMap m_SReplyInfluencerMap;
+    //SStatsInfBloggerBuzzbyday m_SStatsInfBloggerBuzzbyday;
+    //SStatsInfBloggerRank m_SStatsInfBloggerRank;
+    STInfluencer m_STInfluencer;
+    SStatsJson m_SStatsJson;
+
+public:
+    virtual void setInitiaizer(SInitializer &_initializer);
+    virtual bool uploadData(int _companyNum);
+    virtual bool changeTable(int _companyNum);
+    virtual bool makeCategory(SDatagroup &_datagroup, int _nCategory, const QList<SInitializer::stFilter> &_listFilter);
+    virtual bool makeOverallCategory(int _categoryNum);
+    virtual bool makeTable(SDatagroup &_datagroup);
+
+};
+
+
+#endif // SINFLUENCER
+

FilterProcess/sinitializer.cpp

@@ -0,0 +1,715 @@
+#include <QString>
+#include <QSettings>
+#include <QDate>
+#include <QDateTime>
+#include <QVariant>
+#include <QStringList>
+#include <QFile>
+#include <QVector>
+#include <iostream>
+#include <QTextStream>
+#include <QSqlDatabase>
+#include <QSqlQuery>
+#include <QSqlError>
+#include <QDebug>
+#include "sinitializer.h"
+#include "../common.h"
+using namespace std;
+/*
+bool SInitializer::disableIndex(QSqlDatabase& db, QString _tableName, QStringList _strIndexNames, int _nMode)
+{
+    if (_nMode == DEBUG)
+    {
+        return true;
+    }
+
+    QSqlQuery query(db);
+
+    foreach (const QString& strIndex, _strIndexNames)
+    {
+        QString strQuery = "alter table " + _tableName + " drop index " + strIndex;
+
+        if(!query.exec(strQuery.toUtf8()))
+        {
+            insertLog(query.lastQuery());
+            insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    return true;
+}
+
+bool SInitializer::enableIndex(QSqlDatabase& db, QString _tableName, QStringList _strIndexNames, int _nMode)
+{
+    if (_nMode == DEBUG)
+    {
+        return true;
+    }
+
+    QSqlQuery query(db);
+    foreach (const QString& strIndex, _strIndexNames)
+    {
+        QString strQuery = "alter table " + _tableName + " add index (" +strIndex + ")";
+        if(!query.exec(strQuery.toUtf8()))
+        {
+            insertLog(query.lastQuery());
+            insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    return true;
+}
+
+bool SInitializer::disableSettings(QSqlDatabase& db, int _nMode)
+{
+    if (_nMode == DEBUG)
+    {
+        return true;
+    }
+    QSqlQuery query(db);
+    QString strQuery = "SET AUTOCOMMIT = 0; SET FOREIGN_KEY_CHECKS = 0; SET UNIQUE_CHECKS = 0";
+    if(!query.exec(strQuery))
+    {
+        insertLog(query.lastQuery());
+        insertLog(query.lastError().text());
+        return false;
+    }
+    return true;
+}
+
+bool SInitializer::enableSettings(QSqlDatabase& db, int _nMode)
+{
+    if (_nMode == DEBUG)
+    {
+        return true;
+    }
+    QSqlQuery query(db);
+    QString strQuery = "SET AUTOCOMMIT = 1; SET FOREIGN_KEY_CHECKS = 1; SET UNIQUE_CHECKS = 1";
+    if(!query.exec(strQuery))
+    {
+        insertLog(query.lastQuery());
+        insertLog(query.lastError().text());
+        return false;
+    }
+    return true;
+}
+*/
+
+void SInitializer::updateWebDBInfoState(QSqlDatabase &_db, int _nCompany, QString _strStatus)
+{
+    QString strQuery = "update dbinfo set "
+            "status = '" + _strStatus + "' "
+            "where company_num = " + QString::number(_nCompany);
+    _db.exec(strQuery.toUtf8());
+}
+
+void SInitializer::updateWebDBInfoComplete(QSqlDatabase _db, QString _mindate, QString _maxdate, QString _lastupdate, int _bodycount, int _replycount, int _nCompany)
+{
+    QString strQuery = "update dbinfo set "
+            "bodycount = " + QString::number(_bodycount) + " , "
+            "replycount = " + QString::number(_replycount)+" , "
+            "mindate = '" + _mindate + "',"
+            "maxdate = '" + _maxdate + "',"
+            //"lastupdate = '" + _lastupdate + "' "
+            "lastupdate = '" + QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss") + "' "
+            "where company_num = " + QString::number(_nCompany);
+    _db.exec(strQuery.toUtf8());
+}
+
+
+bool SInitializer::initDays()
+{
+    QSettings settings(QString("setup.ini"), QSettings::IniFormat);
+    settings.setIniCodec("UTF-8");
+    settings.beginGroup(QString("settings"));
+    if (settings.childKeys().size() == 0) return false;
+    int nCutDays = settings.value("days").toInt();
+
+    QString strFrom = settings.value("from").toString().trimmed();
+    QString strTo = settings.value("to").toString().trimmed();
+
+    if(!strFrom.isEmpty())
+    {
+        m_strStartDay = strFrom;
+    }
+    else
+    {
+        m_strStartDay = QDate::currentDate().addDays(-abs(nCutDays)).toString("yyyy-MM-dd");
+    }
+    if(!strTo.isEmpty())
+    {
+        m_strEndDay = strTo;
+    }
+    else
+    {
+        m_strEndDay = QDate::currentDate().toString("yyyy-MM-dd");
+    }
+    settings.endGroup();
+    return true;
+}
+
+bool SInitializer::initSpammer()
+{
+    QSettings settings(QString("setup.ini"), QSettings::IniFormat);
+    settings.setIniCodec("UTF-8");
+    settings.beginGroup(QString("spammers"));
+
+    if (settings.childKeys().size() == 0) return false;
+    m_adSpammerParam[E_SPAMER_BODY_COUNT_CUT]    = settings.value("body_cut").toDouble();
+    m_adSpammerParam[E_SPAMER_BODY_COUNT_RATIO]  = settings.value("body_ratio").toDouble();
+    m_adSpammerParam[E_SPAMER_REPLY_COUNT_CUT]   = settings.value("reply_cut").toDouble();
+    m_adSpammerParam[E_SPAMER_REPLY_COUNT_RATIO] = settings.value("reply_ratio").toDouble();
+    m_adSpammerParam[E_SPAMER_NICK_COUNT_CUT]    = settings.value("nick_cut").toDouble();
+    m_adSpammerParam[E_SPAMER_NICK_COUNT_RATIO]  = settings.value("nick_ratio").toDouble();
+    settings.endGroup();
+
+    return true;
+}
+
+
+
+bool SInitializer::initBlogPageNum()
+{
+    QSettings settings(QString("setup.ini"), QSettings::IniFormat);
+    settings.setIniCodec("UTF-8");
+    settings.beginGroup(QString("pagenumber"));
+
+    if (settings.childKeys().size() == 0)
+        m_nBlogPageNum = 10;
+    else
+        m_nBlogPageNum  = settings.value("pagenumber").toInt();
+
+    settings.endGroup();
+    return true;
+}
+
+
+
+bool SInitializer::initDBConnection()
+{
+    QSettings settings(QString("setup.ini"), QSettings::IniFormat);
+    settings.setIniCodec("UTF-8");
+    settings.beginGroup(QString("database"));
+    if (settings.childKeys().size() == 0) return false;
+    m_stWebDBInfo.m_strHostName = settings.value("host").toString();
+    m_stWebDBInfo.m_strUserName = settings.value("user").toString();
+    m_stWebDBInfo.m_strPassword = settings.value("pass").toString();
+    m_stWebDBInfo.m_strDBName = settings.value("name").toString();
+    settings.endGroup();
+
+
+    m_sDBManager.addDatabase("DATA", SDBManager::E_DATABASE_DATA, QString("bigbird.iptime.org"),
+                             QString("admin"), QString("admin123"), QString("concepters"));
+
+    m_sDBManager.addDatabase("WEB", SDBManager::E_DATABASE_WEB,
+                             m_stWebDBInfo.m_strHostName, m_stWebDBInfo.m_strUserName,
+                             m_stWebDBInfo.m_strPassword, m_stWebDBInfo.m_strDBName);
+
+
+    if(!m_sDBManager.open("DATA"))
+    {
+        insertLog("DATA DB open failed");
+        return false;
+    }
+    if(!m_sDBManager.open("WEB"))
+    {
+        insertLog("WEB DB open failed");
+        return false;
+    }
+
+    return true;
+}
+
+bool SInitializer::init(const QString& _strFilterProcessGroupID, const QString& _strFilterProcessGroupName)
+{
+    m_stFilterProcessGroup.m_nFilterProcessGroupID = _strFilterProcessGroupID.toInt();
+    m_stFilterProcessGroup.m_strFilterProcessGroupName = _strFilterProcessGroupName;
+
+    bool b_ok = true;
+    b_ok &= initDBConnection();
+    b_ok &= initColumn();
+    b_ok &= initDays();
+    b_ok &= initInfluencer();
+    b_ok &= initSpammer();
+    b_ok &= initBlogPageNum();
+    b_ok &= initFilterProcess();
+    b_ok &= initCompanyNum();
+    b_ok &= initPlatform();
+    //b_ok &= initConsumerCategory();
+    b_ok &= initCategory();
+    b_ok &= initConsumerMarketer();
+    b_ok &= initConsumerCheckList();
+
+/*
+    if (!b_ok)
+        cout << "FALSE" << endl;
+    else
+        cout << "TRUE" << endl;
+*/
+    return b_ok;
+}
+
+bool SInitializer::initInfluencer()
+{
+    m_stInfluencerParam.m_dBody = 0.4;
+    m_stInfluencerParam.m_dReply = 0.6;
+    return true;
+}
+
+
+bool SInitializer::initFilterProcess()
+{
+    QString strQuery = QString("select filterprocess_type,datagroup_id,filtergroup_id,company_num,category_num,filterprocess_order,service_num "
+                               "from filterprocess where filterprocessgroup_id = ") + QString::number(m_stFilterProcessGroup.m_nFilterProcessGroupID);
+
+    QSqlQuery query(m_sDBManager[SDBManager::E_DATABASE_DATA]);
+
+    if(query.exec(strQuery.toUtf8()) == false)
+    {
+        insertLog(query.lastQuery());
+        insertLog(query.lastError().text());
+        return false;
+    }
+
+    while(query.next())
+    {
+        stFilterProcess stfilterprocess;
+        stfilterprocess.m_nFilterProcessType = query.value(0).toInt();
+        stfilterprocess.m_nDatagroupID = query.value(1).toInt();
+        stfilterprocess.m_nFilterGroupID = query.value(2).toInt();
+        stfilterprocess.m_nCompanyNum = query.value(3).toInt();
+        stfilterprocess.m_nCategoryNum = query.value(4).toInt();
+        stfilterprocess.m_nFilterProcessOrder = query.value(5).toInt();
+        stfilterprocess.m_nServiceNum = query.value(6).toInt();
+        m_listFilterProcess.append(stfilterprocess);
+    }
+
+    query.clear();
+    strQuery = "select type, data from filter where filtergroup_id = ";
+    foreach (const stFilterProcess& stfilterprocess, m_listFilterProcess)
+    {
+        if (stfilterprocess.m_nFilterGroupID == 0)
+            continue;
+
+        if (!query.exec(QString(strQuery + QString::number(stfilterprocess.m_nFilterGroupID)).toUtf8()))
+        {
+            insertLog(query.lastQuery());
+            insertLog(query.lastError().text());
+            return false;
+        }
+        QList<stFilter> listFilter;
+
+        while (query.next())
+        {
+            stFilter stfilter;
+            stfilter.m_nFilterGroupID = stfilterprocess.m_nFilterGroupID;
+            stfilter.m_vData = query.value(1);
+            stfilter.m_nType = query.value(0).toInt();
+            listFilter.append(stfilter);
+        }
+        if (!m_mapFilterGroup.contains(stfilterprocess.m_nFilterGroupID))
+            m_mapFilterGroup.insert(stfilterprocess.m_nFilterGroupID, listFilter);
+
+    }
+    return true;
+}
+
+bool SInitializer::initCategory()
+{
+    for (int i = 0; i < E_SERVICE_MAX; i++)
+    {
+        m_anAllCategory[i] = -1;
+    }
+    int company_num = -1;
+    foreach (const stFilterProcess& stfilterprocess, m_listFilterProcess)
+    {
+        if (stfilterprocess.m_nFilterProcessType == 2)
+        {
+            company_num = stfilterprocess.m_nCompanyNum;
+        }
+    }
+    if (company_num == -1)
+        return false;
+
+    QSqlQuery query(m_sDBManager[SDBManager::E_DATABASE_WEB]);
+
+    QString strQuery = "select num, servicenum, name from category where company_num = ";
+    strQuery += QString::number(company_num) + " order by servicenum asc, num asc";
+
+    if (query.exec(strQuery.toUtf8()) == false)
+    {
+        insertLog(query.lastQuery());
+        insertLog(query.lastError().text());
+        return false;
+    }
+
+    int nService[E_SERVICE_MAX] = {0,};
+
+    while(query.next())
+    {
+        m_mapCategory.insert(query.value(0).toInt(), query.value(2).toString());
+
+        switch(query.value(1).toInt())
+        {
+        case E_SERVICE_INFLUENCER:
+        {
+            if (0 == nService[E_SERVICE_INFLUENCER]++)
+            {
+                m_anAllCategory[E_SERVICE_INFLUENCER] = query.value(0).toInt();
+            }
+            break;
+        }
+        case E_SERVICE_CONSUMER:
+        {
+            if (0 == nService[E_SERVICE_CONSUMER]++)
+            {
+                m_anAllCategory[E_SERVICE_CONSUMER] = query.value(0).toInt();
+            }
+            break;
+        }
+        case E_SERVICE_SPAMMER:
+        {
+            if (0 == nService[E_SERVICE_SPAMMER]++)
+            {
+                m_anAllCategory[E_SERVICE_SPAMMER] = query.value(0).toInt();
+            }
+            break;
+        }
+        case E_SERVICE_POWERCAFE:
+        {
+            if (0 == nService[E_SERVICE_POWERCAFE]++)
+            {
+                m_anAllCategory[E_SERVICE_POWERCAFE] = query.value(0).toInt();
+            }
+            break;
+        }
+        }
+    }
+    return true;
+}
+
+
+bool SInitializer::initConsumerMarketer()
+{
+    if (m_listFilterProcess.isEmpty())
+        return false;
+
+    QString strQuery = QString("select id_id, platformname_num from marketer where company_num = ")
+            + QString::number(m_listFilterProcess.last().m_nCompanyNum);
+
+    QSqlQuery query(m_sDBManager[SDBManager::E_DATABASE_WEB]);
+
+    if(query.exec(strQuery.toUtf8()) == false)
+    {
+        insertLog(query.lastQuery());
+        insertLog(query.lastError().text());
+        return false;
+    }
+
+    while(query.next())
+        m_mapConsumerMaketers.insertMulti(query.value(1).toInt(),
+                                          query.value(0).toString().trimmed());
+
+    return true;
+}
+
+bool SInitializer::initConsumerCheckList()
+{
+    if (m_listFilterProcess.isEmpty())
+        return false;
+
+    QString strQuery = QString("select body_url, id_id, platformname_num from checklist_consumer where company_num = ")
+            + QString::number(m_listFilterProcess.last().m_nCompanyNum);
+
+    QSqlQuery query(m_sDBManager[SDBManager::E_DATABASE_WEB]);
+
+    if(query.exec(strQuery.toUtf8()) == false)
+    {
+        insertLog(query.lastQuery());
+        insertLog(query.lastError().text());
+        return false;
+    }
+
+    while(query.next())
+    {
+        if (!query.value(0).toString().trimmed().isEmpty())
+            m_slConsumerCheckList.append(query.value(0).toString().trimmed());
+        if (!query.value(1).toString().trimmed().isEmpty())
+            m_mapConsumerCheckListUser.insertMulti(query.value(2).toInt(), query.value(1).toString().trimmed());
+    }
+    return true;
+}
+
+QMap<int, QString> SInitializer::getConsumerMaketer()
+{
+    return m_mapConsumerMaketers;
+}
+
+QStringList SInitializer::getConsumerCheckList()
+{
+    return m_slConsumerCheckList;
+}
+
+QMap<int, QString> SInitializer::getConsumerCheckListUser()
+{
+    return m_mapConsumerCheckListUser;
+}
+
+QString SInitializer::getCategoryName(int _nCategory) const
+{
+    return m_mapCategory.value(_nCategory);
+}
+
+/*
+bool SInitializer::initConsumerCategory()
+{
+    QSqlQuery query(m_sDBManager[SDBManager::E_DATABASE_WEB]);
+    int company_num = -1;
+    m_nConsumerAllCategory = -1;
+    foreach (const stFilterProcess& stfilterprocess, m_listFilterProcess)
+    {
+        if (stfilterprocess.m_nFilterProcessType == 1)
+        {
+            QString strQuery = "select statsColumnNum from category where company_num = " +
+                    QString::number(stfilterprocess.m_nCompanyNum) + " and num = " + QString::number(stfilterprocess.m_nCategoryNum);
+            if (!query.exec(strQuery.toUtf8()))
+            {
+                insertLog(query.lastQuery());
+                insertLog(query.lastError().text());
+                return false;
+            }
+            while (query.next())
+            {
+                 m_mapConsumerCategory.insert(stfilterprocess.m_nCategoryNum, query.value(0).toInt());
+            }
+            company_num = stfilterprocess.m_nCompanyNum;
+        }
+    }
+    if (company_num != -1)
+    {
+        QString strQuery = "select num from category where company_num = " + QString::number(company_num) + " and statsColumnNum = 1";
+        if (!query.exec(strQuery.toUtf8()))
+        {
+            insertLog(query.lastQuery());
+            insertLog(query.lastError().text());
+            return false;
+        }
+        while (query.next())
+        {
+            m_nConsumerAllCategory = query.value(0).toInt();
+            m_mapConsumerCategory.insert(m_nConsumerAllCategory ,1);
+        }
+    }
+    return true;
+}
+*/
+/*
+int SInitializer::getConsumerAllCategory()
+{
+    return m_nConsumerAllCategory;
+}
+*/
+
+const double* SInitializer::getSpammerParam() const
+{
+    return m_adSpammerParam;
+}
+
+bool SInitializer::initColumn()
+{
+    m_stColumn.m_slColumn.clear();
+    for (int i = 0; i < E_DATA_MAX; i++)
+        m_stColumn.m_anColumn[i] = -1;
+
+    QVector <QStringList> vecColumn;
+    QFile file("column.txt");
+    if (file.open(QIODevice::ReadOnly | QIODevice::Text) == false) return false;
+    {
+        while (!file.atEnd())
+        {
+            QString str = QString(file.readLine());
+            if (str.at(0) == QChar('#')) continue;
+            if (str.trimmed().isEmpty()) continue;
+            vecColumn.push_back(str.split(","));
+        }
+    }
+    if (vecColumn.size() <= 0) return false;
+
+    foreach (const QStringList& strList,vecColumn)
+        m_stColumn.m_slColumn.push_back(strList.at(E_COLUMN_DATABASE));
+
+    for (QStringList::size_type i = 0; i < m_stColumn.m_slColumn.size(); i++)
+    {
+        if (m_stColumn.m_slColumn[i].trimmed() == QString("platform_title")) m_stColumn.m_anColumn[E_DATA_platform_title] = i;
+        if (m_stColumn.m_slColumn[i].trimmed() == QString("article_form"))  m_stColumn.m_anColumn[E_DATA_article_form] = i;
+        if (m_stColumn.m_slColumn[i].trimmed() == QString("article_parent"))  m_stColumn.m_anColumn[E_DATA_article_parent] = i;
+        if (m_stColumn.m_slColumn[i].trimmed() == QString("article_id"))  m_stColumn.m_anColumn[E_DATA_article_id] = i;
+        if (m_stColumn.m_slColumn[i].trimmed() == QString("article_nickname"))  m_stColumn.m_anColumn[E_DATA_article_nickname] = i;
+        if (m_stColumn.m_slColumn[i].trimmed() == QString("article_title"))  m_stColumn.m_anColumn[E_DATA_article_title] = i;
+        if (m_stColumn.m_slColumn[i].trimmed() == QString("article_data"))  m_stColumn.m_anColumn[E_DATA_article_data] = i;
+        if (m_stColumn.m_slColumn[i].trimmed() == QString("article_url"))  m_stColumn.m_anColumn[E_DATA_article_url] = i;
+        if (m_stColumn.m_slColumn[i].trimmed() == QString("article_hit"))  m_stColumn.m_anColumn[E_DATA_article_hit] = i;
+        if (m_stColumn.m_slColumn[i].trimmed() == QString("article_date"))  m_stColumn.m_anColumn[E_DATA_article_date] = i;
+        if (m_stColumn.m_slColumn[i].trimmed() == QString("article_order"))  m_stColumn.m_anColumn[E_DATA_article_order] = i;
+        if (m_stColumn.m_slColumn[i].trimmed() == QString("platform_id"))  m_stColumn.m_anColumn[E_DATA_platform_id] = i;
+        if (m_stColumn.m_slColumn[i].trimmed() == QString("platform_name"))  m_stColumn.m_anColumn[E_DATA_platform_name] = i;
+        if (m_stColumn.m_slColumn[i].trimmed() == QString("platform_form"))  m_stColumn.m_anColumn[E_DATA_platform_form] = i;
+        if (m_stColumn.m_slColumn[i].trimmed() == QString("reply_url"))  m_stColumn.m_anColumn[E_DATA_reply_url] = i;
+        if (m_stColumn.m_slColumn[i].trimmed() == QString("keyword_id"))  m_stColumn.m_anColumn[E_DATA_keyword_id] = i;
+        if (m_stColumn.m_slColumn[i].trimmed() == QString("article_profileurl")) m_stColumn.m_anColumn[E_DATA_article_profileurl] = i;
+        if (m_stColumn.m_slColumn[i].trimmed() == QString("article_profile")) m_stColumn.m_anColumn[E_DATA_article_profile] = i;
+        if (m_stColumn.m_slColumn[i].trimmed() == QString("etc")) m_stColumn.m_anColumn[E_DATA_etc] = i;
+    }
+    return true;
+}
+
+
+bool SInitializer::initCompanyNum()
+{
+    return true;
+}
+
+void SInitializer::insertLog(const QString& _strMsg) const
+{
+    cout << "[";
+    cout << m_stFilterProcessGroup.m_strFilterProcessGroupName.toStdString();
+    cout << "] ";
+    cout << _strMsg.toStdString() << endl;
+
+    QFile file(m_stFilterProcessGroup.m_strFilterProcessGroupName + "." + QDate::currentDate().toString(Qt::ISODate)+".log");
+    if (!file.open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Append))
+        return;
+
+    QTextStream out(&file);
+    out << QTime::currentTime().toString("[hh:mm:ss] ") << _strMsg << "\n";
+    file.close();
+}
+
+QSqlDatabase SInitializer::getDatabase(const QString& _dbName) const
+{
+    return m_sDBManager[_dbName];
+}
+
+QSqlDatabase SInitializer::getDatabase(const SDBManager::E_DATABASE& _eDatabase) const
+{
+    return m_sDBManager[_eDatabase];
+}
+
+QStringList SInitializer::getColumnStringList() const
+{
+    return m_stColumn.m_slColumn;
+}
+
+QString SInitializer::getStartDay() const
+{
+    return m_strStartDay;
+}
+
+QString SInitializer::getEndDay() const
+{
+    return m_strEndDay;
+}
+
+const int* SInitializer::getColumnIntArray() const
+{
+    return m_stColumn.m_anColumn;
+}
+
+
+int  SInitializer::getBlogPageNum()
+{
+    return m_nBlogPageNum;
+}
+
+
+QList<SInitializer::stFilterProcess> SInitializer::getFilterProcess()
+{
+    return m_listFilterProcess;
+}
+
+QMap<int, QList<SInitializer::stFilter> > SInitializer::getFilterGroup()
+{
+    return m_mapFilterGroup;
+}
+
+bool SInitializer::initPlatform()
+{
+    QString strQuery;
+    strQuery = "select num,form FROM platformform";
+    QSqlQuery query(m_sDBManager[SDBManager::E_DATABASE_WEB]);
+
+    if (!query.exec(strQuery.toUtf8()))
+    {
+        insertLog(query.lastQuery());
+        insertLog(query.lastError().text());
+        return false;
+    }
+    while(query.next())
+        m_stPlatform.m_mapPlatformForm.insert(query.value(1).toString(),query.value(0).toInt());
+
+
+    query.clear();
+    strQuery = "select num,name FROM platformname";
+
+    if (!query.exec(strQuery.toUtf8()))
+    {
+        insertLog(query.lastQuery());
+        insertLog(query.lastError().text());
+        return false;
+    }
+
+    while(query.next())
+        m_stPlatform.m_mapPlatformName.insert(query.value(1).toString(),query.value(0).toInt());
+
+    return true;
+}
+QList<SInitializer::stFilter> SInitializer::getFilterGroup(int _nFilterGroupId)
+{
+    return m_mapFilterGroup[_nFilterGroupId];
+}
+
+int SInitializer::getPlatformForm(const QString &_form)
+{
+    return m_stPlatform.m_mapPlatformForm.value(_form.trimmed(), 1);
+}
+
+int SInitializer::getPlatformName(const QString &_name)
+{
+    return m_stPlatform.m_mapPlatformName.value(_name.trimmed(), 1);
+}
+/*
+QMap<int, int>* SInitializer::getConsumerCategory()
+{
+    return &m_mapConsumerCategory;
+}
+*/
+double SInitializer::getInfluencerParam(int _BodyorReply)
+{
+    return m_stInfluencerParam[_BodyorReply];
+}
+
+void SInitializer::closeConnection(const SDBManager::E_DATABASE _eDatabase)
+{
+    m_sDBManager.close(_eDatabase);
+}
+
+void SInitializer::closeConnection(const QString& _str)
+{
+    m_sDBManager.close(_str);
+}
+
+bool SInitializer::openConnection(const SDBManager::E_DATABASE _eDatabase)
+{
+    return m_sDBManager.open(_eDatabase);
+}
+
+bool SInitializer::openConnection(const QString& _str)
+{
+    return m_sDBManager.open(_str);
+}
+
+int SInitializer::getAllCategoryNum(int _nService)
+{
+    return m_anAllCategory[_nService];
+}
+

FilterProcess/sinitializer.h

@@ -0,0 +1,227 @@
+#ifndef SINITIALIZER
+#define SINITIALIZER
+#include "sdbmanager.h"
+#include <QList>
+#include <QMap>
+#include <QVariant>
+class QString;
+class QStringList;
+class QSqlDatabase;
+
+const int REAL_BODY = 0x01;
+const int REAL_REPLY = 0x02;
+//const int DEBUG = 0;
+//const int RELEASE = 1;
+//const int MODE = RELEASE;
+
+class SInitializer
+{
+
+private:
+    bool initDays();
+    bool initDBConnection();
+    bool initFilterProcess();
+    bool initCompanyNum();
+    bool initColumn();
+    bool initInfluencer();
+    bool initSpammer();
+    bool initPlatform();
+    //bool initConsumerCategory();
+    bool initCategory();
+    bool initBlogPageNum();
+    bool initConsumerMarketer();
+    bool initConsumerCheckList();
+
+
+public:
+    enum E_SPAMER
+    {
+        E_SPAMER_BODY_COUNT_CUT = 0,
+        E_SPAMER_BODY_COUNT_RATIO,
+        E_SPAMER_REPLY_COUNT_CUT,
+        E_SPAMER_REPLY_COUNT_RATIO,
+        E_SPAMER_NICK_COUNT_CUT,
+        E_SPAMER_NICK_COUNT_RATIO,
+        E_SPAMER_MAX
+    };
+
+    enum E_COLUMN
+    {
+        E_COLUMN_DATABASE=0,
+        E_COLUMN_NAME,
+        E_COLUMN_DATE,
+        E_COLUMN_COUNT,
+    };
+
+    enum E_ARTICLE
+    {
+        E_ARTICLE_BODY = 0,
+        E_ARTICLE_REPLY,
+        E_ARTICLE_MAX,
+    };
+
+    enum E_DATA
+    {
+        E_DATA_platform_title = 0,
+        E_DATA_article_form,
+        E_DATA_article_parent,
+        E_DATA_article_id,
+        E_DATA_article_nickname,
+        E_DATA_article_title,
+        E_DATA_article_data,
+        E_DATA_article_url,
+        E_DATA_article_hit,
+        E_DATA_article_date,
+        E_DATA_article_order,
+        E_DATA_platform_id,
+        E_DATA_platform_name,
+        E_DATA_platform_form,
+        E_DATA_reply_url,
+        E_DATA_keyword_id,
+        E_DATA_article_profileurl,
+        E_DATA_article_profile,
+        E_DATA_etc,
+        E_DATA_MAX,
+    };
+    enum E_SERVICE
+    {
+        E_SERVICE_INFLUENCER = 1,
+        E_SERVICE_CONSUMER,
+        E_SERVICE_SPAMMER,
+        E_SERVICE_POWERCAFE,
+        E_SERVICE_MAX
+    };
+
+    struct stDataBaseInfo
+    {
+        QString m_strHostName;
+        QString m_strUserName;
+        QString m_strPassword;
+        QString m_strDBName;
+    };
+    struct stFilterProcessGroup
+    {
+        int m_nFilterProcessGroupID;
+        QString m_strFilterProcessGroupName;
+    };
+    struct stInfluencerParam
+    {
+        double m_dBody;
+        double m_dReply;
+        stInfluencerParam() : m_dBody(0.4), m_dReply(0.6) {}
+        double operator[](const int nSelect) const
+        {
+            switch(nSelect)
+            {
+            case 0:
+                return m_dBody;
+            case 1:
+                return m_dReply;
+            default:
+                return 0.0;
+            }
+        }
+    };
+    struct stColumn
+    {
+        QStringList m_slColumn;
+        int m_anColumn[E_DATA_MAX];
+        stColumn()
+        {
+            for (int i = 0; i < E_DATA_MAX; i++)
+                m_anColumn[i] = -1;
+        }
+    };
+    struct stFilterProcess
+    {
+        int m_nDatagroupID;
+        int m_nFilterGroupID;
+        int m_nCategoryNum;
+        int m_nFilterProcessOrder;
+        int m_nFilterProcessType;
+        int m_nCompanyNum;
+        int m_nServiceNum;
+    };
+
+    struct stFilter
+    {
+        int m_nType;
+        int m_nFilterGroupID;
+        QVariant m_vData;
+        stFilter()
+        {
+            m_nType = -1;
+            m_nFilterGroupID = -1;
+        }
+    };
+    struct stPlatform
+    {
+        QMap<QString, int> m_mapPlatformName;
+        QMap<QString, int> m_mapPlatformForm;
+    };
+
+
+
+private:
+    SDBManager m_sDBManager;
+    QString m_strStartDay;
+    QString m_strEndDay;
+    double m_adSpammerParam[E_SPAMER_MAX];
+    stDataBaseInfo m_stWebDBInfo;
+    int m_nCompanyNum;
+    stFilterProcessGroup m_stFilterProcessGroup;
+    stInfluencerParam m_stInfluencerParam;
+    stColumn m_stColumn;
+    QList<stFilterProcess> m_listFilterProcess;
+    QMap<int, QList<stFilter> > m_mapFilterGroup; // key : filtergroupid
+    int m_nDataGroupNumber;
+    stPlatform m_stPlatform;
+    //QMap<int, int> m_mapConsumerCategory;
+    int m_nConsumerAllCategory;
+    int m_anAllCategory[E_SERVICE_MAX];
+    QMap<int, QString> m_mapCategory;
+    int m_nBlogPageNum;
+    QMap<int, QString> m_mapConsumerMaketers;
+    QMap<int, QString> m_mapConsumerCheckListUser;
+    QStringList m_slConsumerCheckList;
+
+public:
+    bool init(const QString& _strFilterProcessGroupID, const QString& _strFilterProcessGroupName);
+    void insertLog(const QString& _strMsg) const;
+    QSqlDatabase getDatabase(const QString& _dbName) const;
+    QSqlDatabase getDatabase(const SDBManager::E_DATABASE& _eDatabase) const;
+    int getDataGroupNumber() const;
+    QStringList getColumnStringList() const;
+    QString getStartDay() const;
+    QString getEndDay() const;
+    const int* getColumnIntArray() const;
+    QList<stFilterProcess> getFilterProcess();
+    QMap<int, QList<stFilter> > getFilterGroup();
+    const double* getSpammerParam() const;
+    QList<stFilter> getFilterGroup(int _nFilterGroupId);
+    int getPlatformForm(const QString &_form);
+    int getPlatformName(const QString &_name);
+    QMap<int, int>* getConsumerCategory();
+    //int getConsumerAllCategory();
+    void closeConnection(const SDBManager::E_DATABASE _eDatabase);
+    void closeConnection(const QString& _str);
+    bool openConnection(const SDBManager::E_DATABASE _eDatabase);
+    bool openConnection(const QString& _str);
+    double getInfluencerParam(int _BodyorReply);
+    void updateWebDBInfoState(QSqlDatabase &_db, int _nCompany, QString _strStatus);
+    void updateWebDBInfoComplete(QSqlDatabase _db, QString _mindate, QString _maxdate, QString _lastupdate, int _bodycount, int _replycount, int _nCompany);
+    int getAllCategoryNum(int _nService);
+    QString getCategoryName(int _nCategory) const;
+    int getBlogPageNum();
+    QMap<int, QString> getConsumerMaketer();
+    QStringList getConsumerCheckList();
+    QMap<int, QString> getConsumerCheckListUser();
+    //bool disableIndex(QSqlDatabase& db, QString _tableName, QStringList _strIndexNames, int _nMode = MODE);
+    //bool enableIndex(QSqlDatabase& db, QString _tableName, QStringList _strIndexNames, int _nMode = MODE);
+    //bool disableSettings(QSqlDatabase& db, int _nMode = MODE);
+    //bool enableSettings(QSqlDatabase& db, int _nMode = MODE);
+};
+
+
+#endif // SINITIALIZER
+

FilterProcess/spowercafe.h

@@ -0,0 +1,213 @@
+#ifndef SPOWERCAFE
+#define SPOWERCAFE
+#include "sservice.h"
+#include "sfilteralgorithm.h"
+#include "sinitializer.h"
+class QString;
+class QStringList;
+class SPowercafe:public SService
+{
+public:
+    struct stReal
+    {
+        QSet<QString> m_setRealAllUrl;
+        QSet<QString> m_setRealBodyUrl;
+        QMap<QString, int> m_mapRealReplyUniqueUrl; //multiple
+    };
+
+    struct stPowercafe
+    {
+        int category_num;
+        int community_num;
+        QString community_id;
+        int bodycountall;
+        int replycountall;
+        int allcountall;
+        int usercountall;
+        int bodycountreal;
+        int replycountreal;
+        int allcountreal;
+        int usercountreal;
+        int rank;
+
+        QString community_title;
+        QString community_url;
+        int platformname_num;
+        QString platformname_name;
+
+        stPowercafe():category_num(0), community_num(0), bodycountall(0), replycountall(0), allcountall(0), usercountall(0), bodycountreal(0),
+            replycountreal(0), allcountreal(0), usercountreal(0), rank(0), platformname_num(0){}
+    };
+
+    struct stStatsPowCafeRank
+    {
+        QString community_id;
+        QString community_title;
+        int articlecountall;
+        int articlecountreal;
+        int usercountreal;
+        QString subject;
+        int rank;
+        int company_num;
+        stStatsPowCafeRank(): articlecountall(0), articlecountreal(0), usercountreal(0), rank(0), company_num(0){}
+    };
+
+    struct stBodyPowercafeMap
+    {
+        int num;
+        int body_num;
+        int community_num;
+        int category_num;
+        int realin;
+        QString date;
+        int platformname_num;
+        stBodyPowercafeMap():num(0), body_num(0), community_num(0), category_num(0), realin(0), platformname_num(0){}
+    };
+
+    struct stReplyPowercafeMap
+    {
+        int num;
+        int reply_num;
+        int body_num;
+        int community_num;
+        int category_num;
+        int realin;
+        QString body_date;
+        stReplyPowercafeMap():num(0), reply_num(0), body_num(0), community_num(0), category_num(0), realin(0) {}
+    };
+
+    class STPowercafe
+    {
+    private:
+        SInitializer *m_pSInitializer;
+        QList<stPowercafe> m_listMap;
+
+    public:
+        void setInitiaizer(SInitializer &_initializer){ m_pSInitializer = &_initializer; }
+        void clear(){ m_listMap.clear(); }
+        void makeTable(SDatagroup &_datagroup, const QMap<int, stReal>& _mapCategory);
+        bool uploadData(QSqlDatabase &_db, const int &_nCompany);
+        bool changeTable(QSqlDatabase &_db, const int &_nCompany);
+
+    };
+
+    class SStatsPowCafeRank
+    {
+    private:
+        SInitializer *m_pSInitializer;
+        QList<stStatsPowCafeRank> m_listMap;
+
+    public:
+        void setInitiaizer(SInitializer &_initializer){ m_pSInitializer = &_initializer; }
+        void clear(){ m_listMap.clear(); }
+        void makeTable(SDatagroup &_datagroup, const QMap<int, stReal>& _mapCategory);
+        bool uploadData(QSqlDatabase &_db, const int &_nCompany);
+    };
+
+    class SBodyPowercafeMap
+    {
+    private:
+        SInitializer *m_pSInitializer;
+        QList<stBodyPowercafeMap> m_listMap;
+
+    public:
+        void setInitiaizer(SInitializer &_initializer){ m_pSInitializer = &_initializer; }
+        void clear(){ m_listMap.clear(); }
+        void makeTable(SDatagroup &_datagroup, const QMap<int, stReal>& _mapCategory);
+        bool uploadData(QSqlDatabase &_db, const int &_nCompany);
+        bool changeTable(QSqlDatabase &_db, const int &_nCompany);
+    };
+
+    class SReplyPowercafeMap
+    {
+    private:
+        SInitializer *m_pSInitializer;
+        QList<stReplyPowercafeMap> m_listMap;
+
+    public:
+        void setInitiaizer(SInitializer &_initializer){ m_pSInitializer = &_initializer; }
+        void clear(){ m_listMap.clear(); }
+        void makeTable(SDatagroup &_datagroup, const QMap<int, stReal>& _mapCategory);
+        bool uploadData(QSqlDatabase &_db, const int &_nCompany);
+        bool changeTable(QSqlDatabase &_db, const int &_nCompany);
+    };
+
+    struct stStatsJson
+    {
+        int company_num;
+        int servicenum;
+        QString title;
+        QString subtitle;
+        int platformname_num;
+        QString jdata;
+        int category_num;
+        stStatsJson():company_num(0), servicenum(2), platformname_num(1), category_num(0){}
+    };
+
+
+    class SStatsJson
+    {
+    private:
+        SInitializer *m_pSInitializer;
+        QList<stStatsJson> m_listMap;
+    public:
+        void setInitiaizer(SInitializer &_SInitializer) { m_pSInitializer = &_SInitializer; }
+        void makeTable(SDatagroup &_datagroup, const QMap<int, stReal>& _mapCategory);
+        bool uploadData(QSqlDatabase& _db, const int &_nCompany);
+        void clear(){ m_listMap.clear(); }
+    };
+
+    struct stPowercafeRank
+    {
+        int count;
+        QString url;
+        QString community;
+        stPowercafeRank(): count(0){}
+    };
+
+    struct isGreaterCountReal
+    {
+        bool operator()(const stPowercafe& first, const stPowercafe& second)
+        {
+            return first.allcountreal > second.allcountreal;
+        }
+        bool operator()(const stStatsPowCafeRank& first, const stStatsPowCafeRank& second)
+        {
+            return first.articlecountreal > second.articlecountreal;
+        }
+        bool operator()(const stPowercafeRank& first, const stPowercafeRank& second)
+        {
+            return first.count > second.count;
+        }
+    };
+
+    struct isGreaterCountAll
+    {
+        bool operator()(const stStatsPowCafeRank& first, const stStatsPowCafeRank& second)
+        {
+            return first.articlecountall > second.articlecountall;
+        }
+    };
+
+
+
+private:
+    SFilterAlgorithm m_SFilterAlgorithm;
+    QMap<int, stReal> m_mapCategory;
+    SBodyPowercafeMap m_SBodyPowercafeMap;
+    SReplyPowercafeMap m_SReplyPowercafeMap;
+    STPowercafe m_STPowercafe;
+    //SStatsPowCafeRank m_SStatsPowCafeRank;
+    SStatsJson m_SStatsJson;
+
+public:
+    virtual void setInitiaizer(SInitializer &_initializer);
+    virtual bool uploadData(int _companyNum);
+    virtual bool changeTable(int _companyNum);
+    virtual bool makeCategory(SDatagroup &_datagroup, int _nCategory, const QList<SInitializer::stFilter> &_listFilter);
+    virtual bool makeOverallCategory(int _categoryNum);
+    virtual bool makeTable(SDatagroup &_datagroup);
+};
+
+#endif // SPOWERCAFE
+

FilterProcess/sservice.h

@@ -0,0 +1,20 @@
+#ifndef SSERVICE
+#define SSERVICE
+#include "sinitializer.h"
+#include "sdatagroup.h"
+
+class SService
+{
+protected:
+    SInitializer* m_pSInitializer;
+public:
+    virtual void setInitiaizer(SInitializer &_initializer) = 0;
+    virtual bool uploadData(int _companyNum) = 0;
+    virtual bool changeTable(int _companyNum) = 0;
+    virtual bool makeCategory(SDatagroup &_datagroup, int _nCategory, const QList<SInitializer::stFilter> &_listFilter) = 0;
+    virtual bool makeOverallCategory(int _categoryNum) = 0;
+    virtual bool makeTable(SDatagroup &_datagroup) = 0;
+};
+
+#endif // SSERVICE
+

FilterProcess/sspammer.h

@@ -0,0 +1,217 @@
+#ifndef SSPAMMER
+#define SSPAMMER
+#include "sservice.h"
+#include "sfilteralgorithm.h"
+#include "sinitializer.h"
+class QString;
+class QStringList;
+class SSpammer:public SService
+{
+public:
+    struct stReal
+    {
+        QSet<QString> m_setRealAllUrl;
+        QSet<QString> m_setRealBodyUrl;
+        QMap<QString, int> m_mapRealReplyUniqueUrl; //multiple
+    };
+
+    struct stSpammer
+    {
+        int id_num;
+        int category_num;
+        QString id_id;
+        int nicknamecount;
+        int bodycount;
+        int replycount;
+        double spammervalue;
+        int rank;
+        QString platformname_name;
+        int platformname_num;
+        stSpammer():id_num(0), category_num(0), nicknamecount(0), bodycount(0), replycount(0), rank(0), spammervalue(0.0), platformname_num(0){}
+
+    };
+
+    struct stStatsSpaSpammerRank
+    {
+        int id_num;
+        QString id_id;
+        QString platformname_name;
+        int nicknamecount;
+        int bodycount;
+        int replycount;
+        double spammervalue;
+        int rank;
+        QString subject;
+        int company_num;
+        stStatsSpaSpammerRank():id_num(0),nicknamecount(0),bodycount(0),replycount(0),rank(0), spammervalue(0.0){}
+
+    };
+
+    struct stBodySpammerMap
+    {
+        int num;
+        int body_num;
+        int id_num;
+        int category_num;
+        int realin;
+        QString date;
+        int platformname_num;
+        stBodySpammerMap():num(0), body_num(0), id_num(0), category_num(0), realin(0), platformname_num(0){}
+
+    };
+
+    struct stReplySpammerMap
+    {
+        int num;
+        int reply_num;
+        int body_num;
+        int id_num;
+        int category_num;
+        QString body_date;
+        stReplySpammerMap():num(0), body_num(0), reply_num(0), id_num(0), category_num(0){}
+    };
+
+    struct stSpammerScore
+    {
+        int body;
+        int reply;
+        int id_num;
+        QSet<QString> nickname;
+        stSpammerScore():body(0),reply(0), id_num(0){}
+    };
+
+    struct stSpammerRank
+    {
+        double value;
+        int platformform_num;
+        QString id;
+        int id_num;
+        stSpammerRank():value(0.0), platformform_num(1), id_num(0){}
+    };
+
+    struct stBuzzy
+    {
+        int m_nCategory;
+        QMap<QDate, int> m_mapBodyBuzz;
+        QMap<QDate, int> m_mapReplyBuzz;
+    };
+
+    struct stStatsJson
+    {
+        int company_num;
+        int servicenum;
+        QString title;
+        QString subtitle;
+        int platformname_num;
+        QString jdata;
+        int category_num;
+        stStatsJson():company_num(0), servicenum(3), platformname_num(1), category_num(0){}
+    };
+
+    class STSpammer
+    {
+    private:
+        SInitializer *m_pSInitializer;
+        QList<stSpammer> m_listMap;
+    public:
+        void setInitiaizer(SInitializer &_initializer){ m_pSInitializer = &_initializer; }
+        void clear(){ m_listMap.clear(); }
+        void makeTable(SDatagroup &_datagroup, const QMap<int, stReal>& _mapCategory, QSet<int>& setSpammer);
+        bool uploadData(QSqlDatabase &_db, const int &_nCompany);
+        bool changeTable(QSqlDatabase &_db, const int &_nCompany);
+
+    };
+
+    class SStatsSpaSpammerRank
+    {
+    private:
+        SInitializer *m_pSInitializer;
+        QList<stStatsSpaSpammerRank> m_listMap;
+    public:
+        void setInitiaizer(SInitializer &_initializer){ m_pSInitializer = &_initializer; }
+        void clear(){ m_listMap.clear(); }
+        void makeTable(SDatagroup &_datagroup, const QMap<int, stReal>& _mapCategory);
+        bool uploadData(QSqlDatabase &_db, const int &_nCompany);
+    };
+
+    class SBodySpammerMap
+    {
+    private:
+         SInitializer *m_pSInitializer;
+         QList<stBodySpammerMap> m_listMap;
+    public:
+        void setInitiaizer(SInitializer &_initializer){ m_pSInitializer = &_initializer; }
+        void clear(){ m_listMap.clear(); }
+        void makeTable(SDatagroup &_datagroup, const QMap<int, stReal>& _mapCategory ,QSet<int>& setSpammer);
+        bool uploadData(QSqlDatabase &_db, const int &_nCompany);
+        bool changeTable(QSqlDatabase &_db, const int &_nCompany);
+    };
+
+    class SReplySpammerMap
+    {
+    private:
+        SInitializer *m_pSInitializer;
+        QList<stReplySpammerMap> m_listMap;
+    public:
+        void setInitiaizer(SInitializer &_initializer){ m_pSInitializer = &_initializer; }
+        void clear(){ m_listMap.clear(); }
+        void makeTable(SDatagroup &_datagroup, const QMap<int, stReal>& _mapCategory, QSet<int>& setSpammer);
+        bool uploadData(QSqlDatabase &_db, const int &_nCompany);
+        bool changeTable(QSqlDatabase &_db, const int &_nCompany);
+    };
+
+    struct isGreaterSpammerValue
+    {
+        bool operator()(const stSpammer& first, const stSpammer& second) const
+        {
+            return first.spammervalue > second.spammervalue;
+        }
+
+        bool operator()(const stStatsSpaSpammerRank& first, const stStatsSpaSpammerRank& second) const
+        {
+            return first.spammervalue > second.spammervalue;
+        }
+        bool operator()(const stSpammerRank& first, const stSpammerRank& second) const
+        {
+            return first.value > second.value;
+        }
+    };
+
+    class SStatsJson
+    {
+    private:
+        SInitializer *m_pSInitializer;
+        QList<stStatsJson> m_listMap;
+    public:
+        void setInitiaizer(SInitializer &_SInitializer) { m_pSInitializer = &_SInitializer; }
+        void makeTable(SDatagroup &_datagroup, const QMap<int, stReal>& _mapCategory);
+        void makeTableBuzz(SDatagroup &_datagroup, const QMap<int, stReal>& _mapCategory);
+        void makeTableRank(SDatagroup &_datagroup, const QMap<int, stReal>& _mapCategory);
+        bool uploadData(QSqlDatabase& _db, const int &_nCompany);
+        void clear(){ m_listMap.clear(); }
+    };
+
+
+private:
+    SFilterAlgorithm m_SFilterAlgorithm;
+    QMap<int, stReal> m_mapCategory;
+    STSpammer m_STSpammer;
+    //SStatsSpaSpammerRank m_SStatsSpaSpammerRank;
+    SBodySpammerMap m_SBodySpammerMap;
+    SReplySpammerMap m_SReplySpammerMap;
+    QSet<int> m_setSpammer;
+    SStatsJson m_SStatsJson;
+
+public:
+    virtual void setInitiaizer(SInitializer &_initializer);
+    virtual bool uploadData(int _companyNum);
+    virtual bool changeTable(int _companyNum);
+    virtual bool makeCategory(SDatagroup &_datagroup, int _nCategory, const QList<SInitializer::stFilter> &_listFilter);
+    virtual bool makeOverallCategory(int _categoryNum);
+    virtual bool makeTable(SDatagroup &_datagroup);
+};
+
+
+
+#endif // SSPAMMER
+