new filterprocess

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

sfilterprocess/main.cpp

@@ -0,0 +1,37 @@
+#include <iostream>
+#include "sfilterprocess.h"
+#include <QCoreApplication>
+#include <QLocale>
+#include <QDate>
+
+using namespace std;
+int main(int argc, char *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 << "check argument " << endl;
+        return -1;
+    }
+
+
+    if (!filter.init(argv[1], argv[2]))
+    //if (!filter.init(QString::number(370), "Check"))
+    {
+        cout << "filter init error" << endl;
+        exit(1);
+    }
+
+    if (!filter.run())
+    {
+        cout << "filter run error" << endl;
+        exit(1);
+    }
+
+    return 0;
+}

sfilterprocess/sconsumer.cpp

@@ -0,0 +1,514 @@
+#include "sconsumer.h"
+#include <QSqlQuery>
+#include <QSqlDatabase>
+#include <QSqlError>
+#include <QDebug>
+#include <QDateTime>
+#include <QDate>
+
+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;
+    }
+    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;
+    qDebug() << "filtered size: " << vecData[SInitializer::E_ARTICLE_BODY].size();
+    qDebug() << "filtered size: " << vecData[SInitializer::E_ARTICLE_REPLY].size();
+    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);
+}
+
+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++)
+        {
+            streal.m_mapRealReplyUniqueUrl.insertMulti(iterPos1.key(), iterPos1.value());
+        }
+    }
+
+    m_mapCategory.insert(_nCategory, streal);
+    return true;
+}
+
+bool SConsumer::makeTable(SDatagroup &_datagroup)
+{
+    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_pSInitializer->insertLog("Make Reply 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;
+                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;
+
+                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) 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) + ")";
+
+        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)->reply_count == 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::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();
+
+                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();
+                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 (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 (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;
+}

sfilterprocess/sconsumer.h

@@ -0,0 +1,110 @@
+#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;
+        stBodyConsumerMap():num(0), body_num(0), category_num(0), realin(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 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(); }
+    };
+
+private:
+    SFilterAlgorithm m_SFilterAlgorithm;
+    QMap<int, stReal> m_mapCategory;
+    SBodyConsumerMap m_SBodyConsumerMap;
+    SStatsConUserBuzzybyday m_SStatsConUserBuzzybyday;
+
+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);
+};
+
+
+
+
+
+#endif // SCONSUMER
+

sfilterprocess/sdatagroup.h

@@ -0,0 +1,263 @@
+#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);
+
+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 reply_startnum;
+        int reply_endnum;
+        int reply_count;
+        QString lastupdate;
+        QVector<int> realbycategorynum;
+        stBody():reply_endnum(-1), reply_startnum(-1), reply_count(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;
+    };
+    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 community_num;
+        int platformname_num;
+        stId():num(0), id("(none)"), community_num(0), platformname_num(1) {}
+    };
+    struct stNickname
+    {
+        int num;
+        QString nickname;
+        int id_num;
+        stNickname():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);
+        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);
+        QString UniCodeToEucKr(const QString& _strData);
+        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
+

sfilterprocess/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));
+}

sfilterprocess/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
+

sfilterprocess/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(" ");
+        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();
+    }
+}

sfilterprocess/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
+

sfilterprocess/sfilterprocess.cpp

@@ -0,0 +1,96 @@
+#include <QString>
+#include <iostream>
+#include "sfilteralgorithm.h"
+#include "sfilterprocess.h"
+#include "../Json/sjson.h"
+#include <QDebug>
+#include <QSqlDatabase>
+using namespace std;
+
+bool SFilterProcess::init(QString _strFilterProcessGroupID, QString _strFilterProcessGroupName)
+{
+    if (!m_SInitializer.init(_strFilterProcessGroupID, _strFilterProcessGroupName))
+    {
+        cout << "initializer init error" << endl;
+        return false;
+    }
+
+    m_SDatagroup.setInitializer(m_SInitializer);
+    m_SConsumer.setInitiaizer(m_SInitializer);
+    m_SInfluencer.setInitiaizer(m_SInitializer);
+    m_SSpammer.setInitiaizer(m_SInitializer);
+    m_SPowercafe.setInitiaizer(m_SInitializer);
+    m_SInitializer.closeConnection(SDBManager::E_DATABASE_WEB);
+    return true;
+}
+
+bool SFilterProcess::run()
+{
+    m_SInitializer.insertLog("New Filter start");
+    QList<SInitializer::stFilterProcess> listFilterProcess = m_SInitializer.getFilterProcess();
+
+    foreach (SInitializer::stFilterProcess process, listFilterProcess)
+    {
+        switch(process.m_nFilterProcessType)
+        {
+        case E_PROCSS_TYPE_LOAD:
+        {
+            m_SDatagroup.loadData(process.m_nDatagroupID);
+            break;
+        }
+        case E_PROCSS_TYPE_CATEGORY_MAKE:
+        {
+            m_SConsumer.makeCategory(m_SDatagroup, process.m_nCategoryNum, m_SInitializer.getFilterGroup(process.m_nFilterGroupID));
+            break;
+        }
+        case E_PROCSS_TYPE_SEND:
+        {
+            m_SDatagroup.makeTable();
+
+            m_SConsumer.makeOverallCategory(m_SInitializer.getConsumerAllCategory());
+            m_SConsumer.makeTable(m_SDatagroup);
+            m_SInfluencer.makeTable(m_SDatagroup);
+            m_SSpammer.makeTable(m_SDatagroup);
+            m_SPowercafe.makeTable(m_SDatagroup);
+
+            m_SInitializer.openConnection(SDBManager::E_DATABASE_WEB);
+            m_SDatagroup.uploadData(process.m_nCompanyNum);
+            m_SConsumer.uploadData(process.m_nCompanyNum);
+            m_SInfluencer.uploadData(process.m_nCompanyNum);
+            m_SSpammer.uploadData(process.m_nCompanyNum);
+            m_SPowercafe.uploadData(process.m_nCompanyNum);
+
+            m_SDatagroup.changeTable(process.m_nCompanyNum);
+            m_SConsumer.changeTable(process.m_nCompanyNum);
+            m_SInfluencer.changeTable(process.m_nCompanyNum);
+            m_SSpammer.changeTable(process.m_nCompanyNum);
+            m_SPowercafe.changeTable(process.m_nCompanyNum);
+
+            m_SInitializer.updateWebDBInfoComplete(m_SInitializer.getDatabase(SDBManager::E_DATABASE_WEB), m_SDatagroup.getstDate()->m_strMindate,
+                                                   m_SDatagroup.getstDate()->m_strMaxdate, m_SDatagroup.getstDate()->m_strLastupdate,
+                                                   m_SDatagroup.getCounts()->m_nFilterBodyCount, m_SDatagroup.getCounts()->m_nFilterReplyCount,
+                                                   process.m_nCompanyNum);
+            break;
+        }
+        case E_PROCSS_TYPE_INFLUENCE_COUNT:
+        {
+            m_SInfluencer.makeCategory(m_SDatagroup, process.m_nCategoryNum, m_SInitializer.getFilterGroup(process.m_nFilterGroupID));
+            break;
+        }
+        case E_PROCSS_TYPE_SPAMMERS_COUNT:
+        {
+            m_SSpammer.makeCategory(m_SDatagroup, process.m_nCategoryNum, m_SInitializer.getFilterGroup(process.m_nFilterGroupID));
+            break;
+        }
+        case E_PROCSS_TYPE_POWER_CAFE_COUNT:
+        {
+            m_SPowercafe.makeCategory(m_SDatagroup, process.m_nCategoryNum, m_SInitializer.getFilterGroup(process.m_nFilterGroupID));
+            break;
+        }
+    }
+    }
+    m_SInitializer.insertLog("New Filter END");
+
+    return true;
+}
+

sfilterprocess/sfilterprocess.h

@@ -0,0 +1,28 @@
+#ifndef SFILTERPROCESS
+#define SFILTERPROCESS
+#include "sinitializer.h"
+#include "sdatagroup.h"
+#include "sconsumer.h"
+#include "sinfluencer.h"
+#include "sspammer.h"
+#include "spowercafe.h"
+class QString;
+
+class SFilterProcess
+{
+private:
+    SInitializer m_SInitializer;
+    SDatagroup m_SDatagroup;
+    SConsumer m_SConsumer;
+    SInfluencer m_SInfluencer;
+    SSpammer m_SSpammer;
+    SPowercafe m_SPowercafe;
+
+public:
+    bool init(QString _strFilterProcessGroupID, QString _strFilterProcessGroupName);
+    bool run();
+
+};
+
+#endif // SFILTERPROCESS
+

sfilterprocess/sfilterprocess.pro

@@ -0,0 +1,42 @@
+#-------------------------------------------------
+#
+# Project created by QtCreator 2016-02-29T16:47:52
+#
+#-------------------------------------------------
+
+QT       += core sql
+
+QT       -= gui
+
+TARGET = sfilterprocess
+CONFIG   += console
+CONFIG   -= app_bundle
+
+TEMPLATE = app
+
+
+SOURCES += main.cpp \
+    sdbmanager.cpp \
+    sinitializer.cpp \
+    sfilterprocess.cpp \
+    sfilteralgorithm.cpp \
+    ../Json/sjson.cpp \
+    sdatagroup.cpp \
+    sconsumer.cpp \
+    sinfluencer.cpp \
+    sspammer.cpp \
+    spowercafe.cpp
+
+HEADERS += \
+    sdbmanager.h \
+    sinitializer.h \
+    sfilterprocess.h \
+    sfilteralgorithm.h \
+    ../common.h \
+    ../Json/sjson.h \
+    sdatagroup.h \
+    sservice.h \
+    sinfluencer.h \
+    sconsumer.h \
+    sspammer.h \
+    spowercafe.h

sfilterprocess/sinfluencer.cpp

@@ -0,0 +1,873 @@
+#include <QtAlgorithms>
+#include <QSqlQuery>
+#include <QSqlDatabase>
+#include <QVariant>
+#include <QSqlError>
+#include <QDebug>
+#include <QDate>
+#include <QDateTime>
+#include "sinfluencer.h"
+
+void SInfluencer::setInitiaizer(SInitializer &_initializer)
+{
+    m_pSInitializer = &_initializer;
+    m_SBodyInfluencerMap.setInitiaizer(_initializer);
+    m_SReplyInfluencerMap.setInitiaizer(_initializer);
+    m_SStatsInfBloggerBuzzbyday.setInitiaizer(_initializer);
+    m_SStatsInfBloggerRank.setInitiaizer(_initializer);
+    m_STInfluencer.setInitiaizer(_initializer);
+}
+
+bool SInfluencer::uploadData(int _companyNum)
+{
+    m_pSInitializer->insertLog("Start upload influencer");
+
+    QSqlDatabase dbWeb = m_pSInitializer->getDatabase(SDBManager::E_DATABASE_WEB);
+    m_pSInitializer->updateWebDBInfoState(dbWeb, _companyNum, "Influence (Start)");
+    if (!m_SBodyInfluencerMap.uploadData(dbWeb, _companyNum))
+    {
+        m_pSInitializer->insertLog("Fail to upload influencer body map");
+        return false;
+    }
+    if (!m_SReplyInfluencerMap.uploadData(dbWeb, _companyNum))
+    {
+        m_pSInitializer->insertLog("Fail to upload influencer reply map");
+        return false;
+    }
+    if (!m_SStatsInfBloggerBuzzbyday.uploadData(dbWeb, _companyNum))
+    {
+        m_pSInitializer->insertLog("Fail to upload stats_inf_blogger_buzzbyday");
+        return false;
+    }
+    if (!m_SStatsInfBloggerRank.uploadData(dbWeb, _companyNum))
+    {
+        m_pSInitializer->insertLog("Fail to upload stats_inf_blogger_rank");
+        return false;
+    }
+    if (!m_STInfluencer.uploadData(dbWeb, _companyNum))
+    {
+        m_pSInitializer->insertLog("Fail to upload influencer");
+        return false;
+    }
+    m_pSInitializer->insertLog("End upload influencer");
+    m_pSInitializer->updateWebDBInfoState(dbWeb, _companyNum, "Influence (Finish)");
+
+    return true;
+}
+
+bool SInfluencer::changeTable(int _companyNum)
+{
+    m_pSInitializer->insertLog("Start table change influencer");
+    QSqlDatabase dbWeb = m_pSInitializer->getDatabase(SDBManager::E_DATABASE_WEB);
+    if (!m_SBodyInfluencerMap.changeTable(dbWeb, _companyNum))
+    {
+        m_pSInitializer->insertLog("Fail to upload influencer body map");
+        return false;
+    }
+    if (!m_SReplyInfluencerMap.changeTable(dbWeb, _companyNum))
+    {
+        m_pSInitializer->insertLog("Fail to upload influencer reply map");
+        return false;
+    }
+    return true;
+}
+
+bool SInfluencer::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 (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;
+    qDebug() << "filtered size: " << vecData[SInitializer::E_ARTICLE_BODY].size();
+    qDebug() << "filtered size: " << vecData[SInitializer::E_ARTICLE_REPLY].size();
+    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 SInfluencer::makeOverallCategory(int _categoryNum)
+{
+    return true;
+}
+
+bool SInfluencer::makeTable(SDatagroup &_datagroup)
+{
+    m_pSInitializer->insertLog("Make influencer tables");
+    m_pSInitializer->insertLog("Make influencer body tables");
+    m_SBodyInfluencerMap.makeTable(_datagroup, m_mapCategory);
+    m_pSInitializer->insertLog("Make influencer reply tables");
+    m_SReplyInfluencerMap.makeTable(_datagroup, m_mapCategory);
+    m_pSInitializer->insertLog("Make influencer stats_inf_blogger_buzzy tables");
+    m_SStatsInfBloggerBuzzbyday.makeTable(_datagroup, m_mapCategory);
+    m_pSInitializer->insertLog("Make influencer stats_inf_blogger_rank table");
+    m_SStatsInfBloggerRank.makeTable(_datagroup, m_mapCategory);
+    m_pSInitializer->insertLog("Make influencer influencer");
+    m_STInfluencer.makeTable(_datagroup, m_mapCategory);
+    return true;
+}
+
+void SInfluencer::STInfluencer::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 QStringList* orderedUrl = _datagroup.getOrderedUrl();
+    QMap<SDatagroup::stProfileurlKey, stInfluencer> mapRank;
+
+    const int* anColumn = m_pSInitializer->getColumnIntArray();
+
+    for (QMap<int, stReal>::const_iterator iterPos = _mapCategory.constBegin(); iterPos != _mapCategory.constEnd(); iterPos++)
+    {
+        const stReal& streal = iterPos.value();
+        foreach (const QString& _url, *orderedUrl)
+        {
+            if (streal.m_setRealBodyUrl.contains(_url))
+            {
+                SDatagroup::stProfileurlKey stprofileurlkey(m_pSInitializer->getPlatformForm((*mapBody)[_url][anColumn[SInitializer::E_DATA_platform_form]].trimmed()),
+                        (*mapBody)[_url][anColumn[SInitializer::E_DATA_article_id]].trimmed());
+
+                if (!mapRank.contains(stprofileurlkey))
+                {
+                    mapRank.insert(stprofileurlkey, stInfluencer());
+                    mapRank[stprofileurlkey].id_id = _datagroup.getstBody(_url)->id_id;
+                    mapRank[stprofileurlkey].id_num = _datagroup.getstBody(_url)->id_num;
+                    mapRank[stprofileurlkey].nickname_num = _datagroup.getstBody(_url)->nickname_num;
+                    mapRank[stprofileurlkey].community_num = _datagroup.getstBody(_url)->community_num;
+                    mapRank[stprofileurlkey].profile = (*(_datagroup.getmapBody(stprofileurlkey)))[anColumn[SInitializer::E_DATA_article_profile]].trimmed();
+                    mapRank[stprofileurlkey].profileurl = (*(_datagroup.getmapBody(stprofileurlkey)))[anColumn[SInitializer::E_DATA_article_profileurl]].trimmed();
+                }
+                mapRank[stprofileurlkey].bodycount++;
+
+                if ((*mapReply).contains(_url))
+                {
+                    for (QMap<int, QStringList>::const_iterator iterPos1 = (*mapReply)[_url].constBegin(); iterPos1 != (*mapReply)[_url].constEnd(); iterPos1++)
+                    {
+                        //if ((iterPos1.value()[anColumn[SInitializer::E_DATA_article_id]].trimmed() != (*mapBody)[_url][anColumn[SInitializer::E_DATA_article_id]].trimmed()))
+                            mapRank[stprofileurlkey].replycount++;
+                    }
+                }
+            }
+        }
+    }
+
+    for (QMap<SDatagroup::stProfileurlKey, stInfluencer>::iterator iterPos = mapRank.begin(); iterPos != mapRank.end(); iterPos++)
+    {
+        stInfluencer &val = iterPos.value();
+        val.influencervalue = val.bodycount * m_pSInitializer->getInfluencerParam(0) + val.replycount * m_pSInitializer->getInfluencerParam(1);
+    }
+
+    m_listMap = mapRank.values();
+
+    qSort(m_listMap.begin(), m_listMap.end(), isGreaterInfluencerValue());
+
+    int rank = 1;
+    for (QList<stInfluencer>::iterator iterPos = m_listMap.begin(); iterPos != m_listMap.end(); iterPos++)
+    {
+        iterPos->rank = rank++;
+    }
+}
+
+/*
+bool SInfluencer::STInfluencer::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery = "delete from influencer where company_num = " + QString::number(_nCompany);
+    QSqlQuery query(_db);
+    if (query.exec(strQuery.toUtf8()) == false)
+    {
+        m_pSInitializer->insertLog(query.lastQuery());
+        m_pSInitializer->insertLog(query.lastError().text());
+        return false;
+    }
+    strQuery = "insert into influencer (rank,company_num,id_num,nickname_num,community_num,bodycount,replycount,influencervalue,profile,profileurl,id_id)"
+               " VALUES (:RANK,:COMPANY_NUM,:ID_NUM,:NICKNAME_NUM,:COMMUNITY_NUM,:BODY_COUNT,:REPLY_COUNT,:INPL,:PROFILE,:PROFILE_URL,:ID_ID)";
+
+    query.clear();
+    query.prepare(strQuery.toUtf8());
+
+    foreach (const stInfluencer& stinfluencer, m_listMap)
+    {
+        query.bindValue(":RANK", stinfluencer.rank);
+        query.bindValue(":COMPANY_NUM", _nCompany);
+        query.bindValue(":ID_NUM", stinfluencer.id_num);
+        query.bindValue(":NICKNAME_NUM", stinfluencer.nickname_num);
+        query.bindValue(":COMMUNITY_NUM", stinfluencer.community_num);
+        query.bindValue(":BODY_COUNT", stinfluencer.bodycount);
+        query.bindValue(":REPLY_COUNT", stinfluencer.replycount);
+        query.bindValue(":ID_ID", stinfluencer.id_id);
+        query.bindValue(":INPL", QString::number(stinfluencer.influencervalue, 'g', 3));
+        //query.bindValue(":PROFILE", ((stinfluencer.profile.trimmed().isEmpty())? " " : sqlString(stinfluencer.profile).trimmed().replace(QChar(160), "")));
+        //query.bindValue(":PROFILE_URL", ((stinfluencer.profileurl.trimmed().isEmpty())? " ", stinfluencer.profileurl.trimmed()));
+        query.bindValue(":PROFILE", sqlString(stinfluencer.profile).trimmed().replace(QChar(160), ""));
+        query.bindValue(":PROFILE_URL", stinfluencer.profileurl.trimmed());
+        if (query.exec() == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+
+    strQuery = "update dbinfo set influencercount = " + QString::number(m_listMap.size()) + " where company_num = "
+            + QString::number(_nCompany);
+    query.exec(strQuery);
+
+    return true;
+}
+*/
+
+bool SInfluencer::STInfluencer::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery = "delete from influencer where company_num = " + QString::number(_nCompany);
+    QSqlQuery query(_db);
+    if (query.exec(strQuery.toUtf8()) == false)
+    {
+        m_pSInitializer->insertLog(query.lastQuery());
+        m_pSInitializer->insertLog(query.lastError().text());
+        return false;
+    }
+    strQuery = "insert into influencer (rank,company_num,id_num,nickname_num,community_num,bodycount,replycount,influencervalue,profile,profileurl,id_id)"
+               " VALUES (";
+
+    query.clear();
+
+    foreach (const stInfluencer& stinfluencer, m_listMap)
+    {
+        QString str = strQuery;
+        str += QString::number(stinfluencer.rank) + ",";
+        str += QString::number(_nCompany) + ",";
+        str += QString::number(stinfluencer.id_num) + ",";
+        str += QString::number(stinfluencer.nickname_num) + ",";
+        str += QString::number(stinfluencer.community_num) + ",";
+        str += QString::number(stinfluencer.bodycount) + ",";
+        str += QString::number(stinfluencer.replycount) + ",";
+        str += QString::number(stinfluencer.influencervalue, 'g', 3) + ",";
+        str += "'" + sqlString(stinfluencer.profile).trimmed().replace(QChar(160), "") + "',";
+        str += "'" + stinfluencer.profileurl.trimmed() + "',";
+        str += "'" + sqlString(stinfluencer.id_id) + "')";
+        if (query.exec(str.toUtf8()) == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+
+    strQuery = "update dbinfo set influencercount = " + QString::number(m_listMap.size()) + " where company_num = "
+            + QString::number(_nCompany);
+    query.exec(strQuery);
+
+    return true;
+}
+
+void SInfluencer::SStatsInfBloggerRank::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();
+    const int RANK = 10;
+
+    QMap<SDatagroup::stProfileurlKey, stStatsInfBloggerRank> mapRank;
+
+    for (QMap<int, stReal>::const_iterator iterPos = _mapCategory.constBegin(); iterPos != _mapCategory.constEnd(); iterPos++)
+    {
+        const stReal& streal = iterPos.value();
+
+        foreach (const QString& _url, streal.m_setRealBodyUrl)
+        {
+            SDatagroup::stProfileurlKey stprofileurlkey(m_pSInitializer->getPlatformForm((*mapBody)[_url][anColumn[SInitializer::E_DATA_platform_form]].trimmed()),
+                    (*mapBody)[_url][anColumn[SInitializer::E_DATA_article_id]].trimmed());
+
+            if (!mapRank.contains(stprofileurlkey))
+            {
+                mapRank.insert(stprofileurlkey, stStatsInfBloggerRank());
+                mapRank[stprofileurlkey].id_id = (*mapBody)[_url][anColumn[SInitializer::E_DATA_article_id]].trimmed();
+                mapRank[stprofileurlkey].nickname_nickname = (*mapBody)[_url][anColumn[SInitializer::E_DATA_article_nickname]].trimmed();
+            }
+
+            mapRank[stprofileurlkey].bodycount++;
+
+            if ((*mapReply).contains(_url))
+            {
+                for (QMap<int, QStringList>::const_iterator iterPos1 = (*mapReply)[_url].constBegin(); iterPos1 != (*mapReply)[_url].constEnd(); iterPos1++)
+                {
+                    //if ((iterPos1.value()[anColumn[SInitializer::E_DATA_article_id]].trimmed() != (*mapBody)[_url][anColumn[SInitializer::E_DATA_article_id]].trimmed()))
+                        mapRank[stprofileurlkey].replycount++;
+                }
+            }
+        }
+    }
+
+    for (QMap<SDatagroup::stProfileurlKey, stStatsInfBloggerRank>::iterator iterPos = mapRank.begin(); iterPos != mapRank.end(); iterPos++)
+    {
+        stStatsInfBloggerRank &val = iterPos.value();
+        val.influencevalue = val.bodycount * m_pSInitializer->getInfluencerParam(0) + val.replycount * m_pSInitializer->getInfluencerParam(1);
+    }
+
+    QList<stStatsInfBloggerRank> listMap = mapRank.values();
+
+    qSort(listMap.begin(), listMap.end(), isGreaterInfluencerValue());
+    // influencevalue
+    for(int i = 0; i < RANK; i++)
+    {
+        listMap[i].rank = i + 1;
+        listMap[i].subject = "influencevalue";
+        m_listMap.append(listMap.at(i));
+        //qDebug() << listMap[i].id_id;
+    }
+
+    qSort(listMap.begin(), listMap.end(), isGreaterBodyCount());
+    // influencevalue
+    for(int i = 0; i < RANK; i++)
+    {
+        listMap[i].rank = i + 1;
+        listMap[i].subject = "bodycount";
+        m_listMap.append(listMap.at(i));
+        //qDebug() << listMap[i].id_id;
+    }
+
+    qSort(listMap.begin(), listMap.end(), isGreaterReplyCount());
+    // influencevalue
+    for(int i = 0; i < RANK; i++)
+    {
+        listMap[i].rank = i + 1;
+        listMap[i].subject = "replycount";
+        m_listMap.append(listMap.at(i));
+        //qDebug() << listMap[i].id_id;
+    }
+    listMap.clear();
+}
+
+/*
+bool SInfluencer::SStatsInfBloggerRank::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    //_db.transaction();
+    QString strQuery = "delete from stats_inf_blogger_rank where company_num = " + QString::number(_nCompany);
+    QSqlQuery query(_db);
+    if (query.exec(strQuery.toUtf8()) == false)
+    {
+        m_pSInitializer->insertLog(query.lastQuery());
+        m_pSInitializer->insertLog(query.lastError().text());
+        return false;
+    }
+    //_db.commit();
+    //_db.transaction();
+    strQuery = "insert into stats_inf_blogger_rank(rank,id_id,nickname_nickname,bodycount,replycount,influencevalue,subject,company_num)"
+               " VALUES (:rank,:id_id,:nickname_nickname,:bodycount,:replycount,:influencevalue,:subject,:company_num)";
+    query.clear();
+    query.prepare(strQuery.toUtf8());
+
+    foreach (const stStatsInfBloggerRank& ststats, m_listMap)
+    {
+        query.bindValue(":rank", ststats.rank);
+        query.bindValue(":id_id", ststats.id_id);
+        query.bindValue(":company_num", _nCompany);
+        query.bindValue(":nickname_nickname", ststats.nickname_nickname);
+        query.bindValue(":bodycount", ststats.bodycount);
+        query.bindValue(":replycount", ststats.replycount);
+        query.bindValue(":influencevalue", QString::number(ststats.influencevalue, 'g', 3));
+        query.bindValue(":subject", ststats.subject);
+        if (query.exec() == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    //_db.commit();
+    return true;
+}
+*/
+
+bool SInfluencer::SStatsInfBloggerRank::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    //_db.transaction();
+    QString strQuery = "delete from stats_inf_blogger_rank where company_num = " + QString::number(_nCompany);
+    QSqlQuery query(_db);
+    if (query.exec(strQuery.toUtf8()) == false)
+    {
+        m_pSInitializer->insertLog(query.lastQuery());
+        m_pSInitializer->insertLog(query.lastError().text());
+        return false;
+    }
+    //_db.commit();
+    //_db.transaction();
+    strQuery = "insert into stats_inf_blogger_rank(rank,id_id,nickname_nickname,bodycount,replycount,influencevalue,subject,company_num)"
+               " VALUES (";
+    query.clear();
+
+    foreach (const stStatsInfBloggerRank& ststats, m_listMap)
+    {
+        QString str = strQuery;
+        str += QString::number(ststats.rank) + ",";
+        str += "'" + sqlString(ststats.id_id) + "',";
+        str += "'" + sqlString(ststats.nickname_nickname) + "',";
+        str += QString::number(ststats.bodycount) + ",";
+        str += QString::number(ststats.replycount) + ",";
+        str += QString::number(ststats.influencevalue, 'g', 3) + ",";
+        str += "'" + ststats.subject + "',";
+        str += QString::number(_nCompany) + ")";
+        if (query.exec(str.toUtf8()) == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    //_db.commit();
+    return true;
+}
+
+
+void SInfluencer::SStatsInfBloggerBuzzbyday::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<QDate, stInfluenceBuzz> map;
+
+    for (QMap<int, stReal>::const_iterator iterPos = _mapCategory.constBegin(); iterPos != _mapCategory.constEnd(); iterPos++)
+    {
+        const stReal& streal = iterPos.value();
+        foreach (const QString& _url, streal.m_setRealBodyUrl)
+        {
+            QDate date = QDateTime::fromString((*mapBody)[_url][anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd HH:mm:ss").date();
+            dateStart = (date < dateStart ) ? date : dateStart;
+            dateEnd = (date > dateEnd ) ? date : dateEnd;
+            if (!map.contains(date))
+                map.insert(date, stInfluenceBuzz());
+            map[date].bodycount++;
+            map[date].idcount.insert((*mapBody)[_url][anColumn[SInitializer::E_DATA_article_id]].trimmed());
+        }
+        if (streal.m_mapRealReplyUniqueUrl.size() > 0)
+        {
+            for (QMap<QString, int>::const_iterator iterPos1 = streal.m_mapRealReplyUniqueUrl.constBegin(); iterPos1 != streal.m_mapRealReplyUniqueUrl.constEnd(); iterPos1++)
+            {
+                QDate date = QDateTime::fromString((*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "),
+                            "yyyy-MM-dd HH:mm:ss").date();
+                dateStart = (date < dateStart ) ? date : dateStart;
+                dateEnd = (date > dateEnd ) ? date : dateEnd;
+                if (!map.contains(date))
+                    map.insert(date, stInfluenceBuzz());
+                map[date].replycount++;
+            }
+        }
+        else
+        {
+            foreach (const QString& _url, streal.m_setRealBodyUrl)
+            {
+                for (QMap<int, QStringList>::const_iterator iterPos1 = mapReply->value(_url).constBegin(); iterPos1 != mapReply->value(_url).constEnd(); iterPos1++)
+                {
+                    QDate date = QDateTime::fromString((*iterPos1)[anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "),
+                                "yyyy-MM-dd HH:mm:ss").date();
+                    dateStart = (date < dateStart ) ? date : dateStart;
+                    dateEnd = (date > dateEnd ) ? date : dateEnd;
+                    if (!map.contains(date))
+                        map.insert(date, stInfluenceBuzz());
+                    map[date].replycount++;
+                }
+            }
+        }
+    }
+
+    for (QDate date = dateStart; date <= dateEnd; date = date.addDays(1))
+    {
+        if (!map.contains(date))
+            map.insert(date, stInfluenceBuzz());
+        stStatsInfBloggerBuzzbyday ststats;
+
+        ststats.date = date.toString("yyyy-MM-dd");
+        ststats.formateddate = date.toString("yyyyMMdd").toInt();
+        ststats.bodycount = map[date].bodycount;
+        ststats.idcount = map[date].idcount.size();
+        ststats.replycount = map[date].replycount;
+        m_listMap.append(ststats);
+    }
+}
+/*
+bool SInfluencer::SStatsInfBloggerBuzzbyday::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    //_db.transaction();
+    QString strQuery = "delete from stats_inf_blogger_buzzbyday where company_num = " + QString::number(_nCompany);
+    QSqlQuery query(_db);
+    if (query.exec(strQuery.toUtf8()) == false)
+    {
+        m_pSInitializer->insertLog(query.lastQuery());
+        m_pSInitializer->insertLog(query.lastError().text());
+        return false;
+    }
+    //_db.commit();
+    //_db.transaction();
+    strQuery = "insert into stats_inf_blogger_buzzbyday (company_num,date,formateddate,idcount,bodycount,replycount) "
+               "VALUES (:company_num,:date,:formateddate,:idcount,:bodycount,:replycount)";
+    query.clear();
+    query.prepare(strQuery.toUtf8());
+
+    foreach (const stStatsInfBloggerBuzzbyday& ststats, m_listMap)
+    {
+        query.bindValue(":company_num", _nCompany);
+        query.bindValue(":date", ststats.date);
+        query.bindValue(":formateddate", ststats.formateddate);
+        query.bindValue(":idcount", ststats.idcount);
+        query.bindValue(":bodycount", ststats.bodycount);
+        query.bindValue(":replycount", ststats.replycount);
+
+        if (query.exec() == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    //_db.commit();
+    return true;
+}
+*/
+
+
+bool SInfluencer::SStatsInfBloggerBuzzbyday::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery = "delete from stats_inf_blogger_buzzbyday where company_num = " + QString::number(_nCompany);
+    QSqlQuery query(_db);
+    if (query.exec(strQuery.toUtf8()) == false)
+    {
+        m_pSInitializer->insertLog(query.lastQuery());
+        m_pSInitializer->insertLog(query.lastError().text());
+        return false;
+    }
+    strQuery = "insert into stats_inf_blogger_buzzbyday (company_num,date,formateddate,idcount,bodycount,replycount) "
+               "VALUES (";
+    query.clear();
+
+    foreach (const stStatsInfBloggerBuzzbyday& ststats, m_listMap)
+    {
+        QString str = strQuery;
+        str += QString::number(_nCompany) + ",";
+        str += "'" + ststats.date + "',";
+        str += QString::number(ststats.formateddate) + ",";
+        str += QString::number(ststats.idcount) + ",";
+        str += QString::number(ststats.bodycount) + ",";
+        str += QString::number(ststats.replycount) + ")";
+        if (query.exec(str.toUtf8()) == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    return true;
+}
+
+
+void SInfluencer::SBodyInfluencerMap::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))
+            {
+                stBodyInfluencerMap stbody;
+                stbody.num = num++;
+                stbody.body_num = _datagroup.getstBodyNum(strUrl);
+                stbody.id_num = _datagroup.getstBody(strUrl)->id_num;
+                stbody.category_num = iterPos.key();
+                stbody.realin |= REAL_BODY;
+                m_listMap.append(stbody);
+                //_datagroup.addRealBodyCategory(strUrl, iterPos.key());
+                if (streal.m_mapRealReplyUniqueUrl.contains(strUrl))
+                {
+                    stbody.realin |= REAL_REPLY;
+                    /*
+                    foreach (int order, streal.m_mapRealReplyUniqueUrl.values(strUrl))
+                    {
+                        _datagroup.addRealReplyCategory(strUrl, order, iterPos.key());
+                    }
+                    */
+                }
+            }
+        }
+    }
+}
+/*
+bool SInfluencer::SBodyInfluencerMap::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery = "truncate body_influencer_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 = "insert into body_influencer_map_" + QString::number(_nCompany) + "_update (num,category_num,id_num,body_num,realin)"
+            " values (:num,:category_num,:id_num,:body_num,:realin)";
+    query.clear();
+    query.prepare(strQuery.toUtf8());
+
+    foreach (const stBodyInfluencerMap& stmap, m_listMap)
+    {
+        query.bindValue(":num", stmap.num);
+        query.bindValue(":category_num", stmap.category_num);
+        query.bindValue(":id_num", stmap.id_num);
+        query.bindValue(":body_num", stmap.body_num);
+        query.bindValue(":realin", stmap.realin);
+        if (query.exec() == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    return true;
+}
+*/
+
+
+bool SInfluencer::SBodyInfluencerMap::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery = "truncate body_influencer_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 = "insert into body_influencer_map_" + QString::number(_nCompany) + "_update (num,category_num,id_num,body_num,realin)"
+            " values (";
+    query.clear();
+
+
+    foreach (const stBodyInfluencerMap& stmap, m_listMap)
+    {
+        QString str = strQuery;
+        str += QString::number(stmap.num) + ",";
+        str += QString::number(stmap.category_num) + ",";
+        str += QString::number(stmap.id_num) + ",";
+        str += QString::number(stmap.body_num) + ",";
+        str += QString::number(stmap.realin) + ")";
+
+        if (query.exec(str.toUtf8()) == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    return true;
+}
+
+
+
+
+void SInfluencer::SReplyInfluencerMap::makeTable(SDatagroup &_datagroup, const QMap<int, stReal> &_mapCategory)
+{
+    int num = 0;
+    const QMap<QString, QMap<int, QStringList> >* mapReply = _datagroup.getmapReply();
+
+    for (QMap<int, stReal>::const_iterator iterPos = _mapCategory.constBegin(); iterPos != _mapCategory.constEnd(); iterPos++)
+    {
+        const stReal& streal = iterPos.value();
+
+        if (streal.m_mapRealReplyUniqueUrl.size() > 0)
+        {
+            for (QMap<QString, int>::const_iterator iterPos1 = streal.m_mapRealReplyUniqueUrl.constBegin(); iterPos1 != streal.m_mapRealReplyUniqueUrl.end(); iterPos1++)
+            {
+                stReplyInfluencerMap streply;
+                streply.num = num++;
+                streply.body_num = _datagroup.getstBodyNum(iterPos1.key());
+                streply.category_num = iterPos.key();
+                streply.realin |= REAL_REPLY;
+                streply.id_num = _datagroup.getstReply(iterPos1.key(), iterPos1.value())->id_num;
+                streply.reply_num = _datagroup.getstReply(iterPos1.key(), iterPos1.value())->num;
+                m_listMap.append(streply);
+
+                /*
+                foreach (int order, streal.m_mapRealReplyUniqueUrl.values(strUrl))
+                {
+                    _datagroup.addRealReplyCategory(strUrl, order, iterPos.key());
+                }
+                */
+            }
+        }
+        else
+        {
+            foreach (const QString& _url, streal.m_setRealBodyUrl)
+            {
+                for (QMap<int, QStringList>::const_iterator iterPos1 = mapReply->value(_url).constBegin(); iterPos1 != mapReply->value(_url).constEnd(); iterPos1++)
+                {
+                    stReplyInfluencerMap streply;
+                    streply.num = num++;
+                    streply.body_num = _datagroup.getstBodyNum(_url);
+                    streply.category_num = iterPos.key();
+                    streply.realin |= REAL_REPLY;
+                    streply.id_num = _datagroup.getstReply(_url, iterPos1.key())->id_num;
+                    streply.reply_num = _datagroup.getstReply(_url, iterPos1.key())->num;
+                    m_listMap.append(streply);
+                }
+            }
+        }
+    }
+}
+
+
+/*
+bool SInfluencer::SReplyInfluencerMap::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery = "truncate reply_influencer_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 = "insert into reply_influencer_map_" + QString::number(_nCompany) + "_update (num,category_num,id_num,body_num,reply_num,realin)"
+            " values (:num,:category_num,:id_num,:body_num,:reply_num,:realin)";
+    query.clear();
+    query.prepare(strQuery.toUtf8());
+
+    foreach (const stReplyInfluencerMap& stmap, m_listMap)
+    {
+        query.bindValue(":num", stmap.num);
+        query.bindValue(":category_num", stmap.category_num);
+        query.bindValue(":id_num", stmap.id_num);
+        query.bindValue(":body_num", stmap.body_num);
+        query.bindValue(":realin", stmap.realin);
+        query.bindValue(":reply_num", stmap.reply_num);
+        if (query.exec() == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    return true;
+}
+*/
+
+bool SInfluencer::SReplyInfluencerMap::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery = "truncate reply_influencer_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 = "insert into reply_influencer_map_" + QString::number(_nCompany) +
+            "_update (num,category_num,id_num,body_num,reply_num,realin)"
+            " values (";
+    query.clear();
+
+    foreach (const stReplyInfluencerMap& stmap, m_listMap)
+    {
+        QString str = strQuery;
+        str += QString::number(stmap.num) + ",";
+        str += QString::number(stmap.category_num) + ",";
+        str += QString::number(stmap.id_num) + ",";
+        str += QString::number(stmap.body_num) + ",";
+        str += QString::number(stmap.reply_num) + ",";
+        str += QString::number(stmap.realin) + ")";
+        if (query.exec(str.toUtf8()) == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    return true;
+}
+
+
+bool SInfluencer::SBodyInfluencerMap::changeTable(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery;
+    QSqlQuery query(_db);
+    strQuery = "RENAME TABLE ";
+    strQuery += "body_influencer_map_" + QString::number(_nCompany) + " TO " + "body_influencer_map_" + QString::number(_nCompany) + "_temp" + ",";
+    strQuery += "body_influencer_map_" + QString::number(_nCompany) + "_update" + " TO " + "body_influencer_map_" + QString::number(_nCompany) + ",";
+    strQuery += "body_influencer_map_" + QString::number(_nCompany) + "_temp" + " TO " + "body_influencer_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 SInfluencer::SReplyInfluencerMap::changeTable(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery;
+    QSqlQuery query(_db);
+    strQuery = "RENAME TABLE ";
+    strQuery += "reply_influencer_map_" + QString::number(_nCompany) + " TO " + "reply_influencer_map_" + QString::number(_nCompany) + "_temp" + ",";
+    strQuery += "reply_influencer_map_" + QString::number(_nCompany) + "_update" + " TO " + "reply_influencer_map_" + QString::number(_nCompany) + ",";
+    strQuery += "reply_influencer_map_" + QString::number(_nCompany) + "_temp" + " TO " + "reply_influencer_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;
+}
+
+

sfilterprocess/sinfluencer.h

@@ -0,0 +1,216 @@
+#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 company_num;
+        QString id_id;
+        QString profile;
+        QString profileurl;
+        int bodycount;
+        int replycount;
+        double influencervalue;
+        int rank;
+        stInfluencer()
+        {
+            id_num = nickname_num = community_num = company_num = bodycount = replycount = rank = 0;
+            influencervalue = 0.0;
+        }
+
+    };
+    struct stStatsInfBloggerRank
+    {
+        QString id_id;
+        QString nickname_nickname;
+        int bodycount;
+        int replycount;
+        double influencevalue;
+        QString subject;
+        int company_num;
+        int rank;
+        stStatsInfBloggerRank()
+        {
+            bodycount = replycount = 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;
+        stBodyInfluencerMap():num(0),body_num(0), id_num(0), category_num(0), realin(0) {}
+    };
+    struct stReplyInfluencerMap
+    {
+        int num;
+        int reply_num;
+        int body_num;
+        int id_num;
+        int category_num;
+        int realin;
+        stReplyInfluencerMap()
+        {
+            num = reply_num = body_num = id_num = category_num = realin = 0;
+        }
+    };
+    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);
+        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);
+    };
+
+    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);
+    };
+
+    struct isGreaterInfluencerValue
+    {
+        bool operator()(const stInfluencer& first,  const stInfluencer& second)
+        {
+            return first.influencervalue > second.influencervalue;
+        }
+        bool operator()(const stStatsInfBloggerRank& first, const stStatsInfBloggerRank& second)
+        {
+            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;
+
+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
+

sfilterprocess/sinitializer.cpp

@@ -0,0 +1,527 @@
+#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 + "' "
+            "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::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 &= initFilterProcess();
+    b_ok &= initCompanyNum();
+    b_ok &= initPlatform();
+    b_ok &= initConsumerCategory();
+/*
+    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 "
+                               "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();
+        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::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;
+}
+
+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);
+}

sfilterprocess/sinitializer.h

@@ -0,0 +1,202 @@
+#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();
+
+
+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,
+    };
+
+    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;
+    };
+
+    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;
+
+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);
+    //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
+

sfilterprocess/spowercafe.cpp

@@ -0,0 +1,758 @@
+#include <QDebug>
+#include <QString>
+#include <QVariant>
+#include <QSqlQuery>
+#include <QSqlDatabase>
+#include <QSqlError>
+#include "spowercafe.h"
+
+void SPowercafe::setInitiaizer(SInitializer &_initializer)
+{
+    m_pSInitializer = &_initializer;
+    m_SBodyPowercafeMap.setInitiaizer(_initializer);
+    m_SReplyPowercafeMap.setInitiaizer(_initializer);
+    m_STPowercafe.setInitiaizer(_initializer);
+    m_SStatsPowCafeRank.setInitiaizer(_initializer);
+}
+
+bool SPowercafe::uploadData(int _companyNum)
+{
+    m_pSInitializer->insertLog("Start upload Powercafe");
+
+    QSqlDatabase dbWeb = m_pSInitializer->getDatabase(SDBManager::E_DATABASE_WEB);
+    m_pSInitializer->updateWebDBInfoState(dbWeb, _companyNum, "Powercafe (Start)");
+    if (!m_SBodyPowercafeMap.uploadData(dbWeb, _companyNum))
+    {
+        m_pSInitializer->insertLog("Fail to upload Powercafe body map");
+        return false;
+    }
+    if (!m_SReplyPowercafeMap.uploadData(dbWeb, _companyNum))
+    {
+        m_pSInitializer->insertLog("Fail to upload Powercafe reply map");
+        return false;
+    }
+    if (!m_SStatsPowCafeRank.uploadData(dbWeb, _companyNum))
+    {
+        m_pSInitializer->insertLog("Fail to upload stats_pow_cafe_rank");
+        return false;
+    }
+    if (!m_STPowercafe.uploadData(dbWeb, _companyNum))
+    {
+        m_pSInitializer->insertLog("Fail to upload Powercafe");
+        return false;
+    }
+    m_pSInitializer->insertLog("End upload Powercafe");
+    m_pSInitializer->updateWebDBInfoState(dbWeb, _companyNum, "Powercafe (Finish)");
+
+    return true;
+}
+
+bool SPowercafe::changeTable(int _companyNum)
+{
+    m_pSInitializer->insertLog("Start table change powercafe");
+    QSqlDatabase dbWeb = m_pSInitializer->getDatabase(SDBManager::E_DATABASE_WEB);
+    if (!m_SBodyPowercafeMap.changeTable(dbWeb, _companyNum))
+    {
+        m_pSInitializer->insertLog("Fail to upload powercafe body map");
+        return false;
+    }
+    if (!m_SReplyPowercafeMap.changeTable(dbWeb, _companyNum))
+    {
+        m_pSInitializer->insertLog("Fail to upload powercafe reply map");
+        return false;
+    }
+    return true;
+}
+
+bool SPowercafe::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;
+    qDebug() << "filtered size: " << vecData[SInitializer::E_ARTICLE_BODY].size();
+    qDebug() << "filtered size: " << vecData[SInitializer::E_ARTICLE_REPLY].size();
+    const int *anColumn = m_pSInitializer->getColumnIntArray();
+    if (bFiltered[SInitializer::E_ARTICLE_BODY])
+    {
+        foreach (const QStringList& strlist, vecData[SInitializer::E_ARTICLE_BODY])
+        {
+            if (strlist[anColumn[SInitializer::E_DATA_platform_form]].trimmed() != "cafe")
+                continue;
+            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])
+        {
+            if (strlist[anColumn[SInitializer::E_DATA_platform_form]].trimmed() != "cafe")
+                continue;
+            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 SPowercafe::makeOverallCategory(int _categoryNum)
+{
+    return true;
+}
+
+bool SPowercafe::makeTable(SDatagroup &_datagroup)
+{
+    m_pSInitializer->insertLog("Make powercafe tables");
+    m_pSInitializer->insertLog("Make powercafe body tables");
+    m_SBodyPowercafeMap.makeTable(_datagroup, m_mapCategory);
+    m_pSInitializer->insertLog("Make powercafe reply tables");
+    m_SReplyPowercafeMap.makeTable(_datagroup, m_mapCategory);
+    m_pSInitializer->insertLog("Make powercafe stats_pow_cafe_rank tables");
+    m_SStatsPowCafeRank.makeTable(_datagroup, m_mapCategory);
+    m_pSInitializer->insertLog("Make powercafe powercafe table");
+    m_STPowercafe.makeTable(_datagroup, m_mapCategory);
+    return true;
+
+}
+
+void SPowercafe::STPowercafe::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();
+    QMap<QString, stPowercafe> mapPowercafeAll;
+
+    QMap<QString, QSet<QString> > mapUserAll;
+    QMap<QString, QSet<QString> > mapUserReal;
+
+
+    for (QMap<QString, QStringList>::const_iterator iterPos = mapBody->constBegin(); iterPos != mapBody->constEnd(); iterPos++)
+    {
+        if (iterPos.value()[anColumn[SInitializer::E_DATA_platform_form]].trimmed() != "cafe")
+            continue;
+
+        QString strKey = iterPos.value()[anColumn[SInitializer::E_DATA_platform_id]].trimmed();
+        if (!mapPowercafeAll.contains(strKey))
+        {
+            mapPowercafeAll.insert(strKey, stPowercafe());
+            mapUserAll.insert(strKey, QSet<QString>());
+        }
+        mapPowercafeAll[strKey].bodycountall++;
+        mapUserAll[strKey].insert(iterPos.value().at(anColumn[SInitializer::E_DATA_article_id]).trimmed());
+    }
+
+    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++)
+        {
+            if (iterPos1.value()[anColumn[SInitializer::E_DATA_platform_form]].trimmed() != "cafe")
+                continue;
+
+            QString strKey = iterPos1.value().at(anColumn[SInitializer::E_DATA_platform_id]).trimmed();
+            if (!mapPowercafeAll.contains(strKey))
+            {
+                mapPowercafeAll.insert(strKey, stPowercafe());
+                mapUserAll.insert(strKey, QSet<QString>());
+            }
+            mapPowercafeAll[strKey].replycountall++;
+            mapUserAll[strKey].insert(iterPos1.value().at(anColumn[SInitializer::E_DATA_article_id]).trimmed());
+        }
+    }
+
+    for (QMap<int, stReal>::const_iterator iterPos = _mapCategory.constBegin(); iterPos != _mapCategory.constEnd(); iterPos++)
+    {
+        QMap<QString, stPowercafe> mapPowercafeReal;
+        const stReal& streal = iterPos.value();
+
+        foreach (const QString& url, streal.m_setRealBodyUrl)
+        {
+            QString strKey = (*mapBody)[url][anColumn[SInitializer::E_DATA_platform_id]].trimmed();
+            if (!mapPowercafeReal.contains(strKey))
+            {
+                mapPowercafeReal.insert(strKey, stPowercafe());
+                mapPowercafeReal[strKey].community_id = _datagroup.getstCommunity((*mapBody)[url])->id;
+                mapPowercafeReal[strKey].community_num = _datagroup.getstCommunity((*mapBody)[url])->num;
+                mapPowercafeReal[strKey].bodycountall = mapPowercafeAll[strKey].bodycountall;
+                mapPowercafeReal[strKey].replycountall = mapPowercafeAll[strKey].replycountall;
+                mapPowercafeReal[strKey].allcountall = mapPowercafeAll[strKey].bodycountall + mapPowercafeAll[strKey].replycountall;
+                mapPowercafeReal[strKey].usercountall = mapUserAll[strKey].size();
+                mapUserReal.insert(strKey, QSet<QString>());
+            }
+            mapPowercafeReal[strKey].bodycountreal++;
+            mapUserReal[strKey].insert((*mapBody)[url][anColumn[SInitializer::E_DATA_article_id]].trimmed());
+        }
+
+        for (QMap<QString, int>::const_iterator iterPos1 = streal.m_mapRealReplyUniqueUrl.begin(); iterPos1 != streal.m_mapRealReplyUniqueUrl.constEnd(); iterPos1++)
+        {
+            QString strKey = (*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_platform_id]].trimmed();
+            if (!mapPowercafeReal.contains(strKey))
+            {
+                mapPowercafeReal.insert(strKey, stPowercafe());
+                mapPowercafeReal[strKey].community_id = _datagroup.getstCommunity((*mapReply)[iterPos1.key()][iterPos1.value()])->id;
+                mapPowercafeReal[strKey].community_num = _datagroup.getstCommunity((*mapReply)[iterPos1.key()][iterPos1.value()])->num;
+                mapPowercafeReal[strKey].bodycountall = mapPowercafeAll[strKey].bodycountall;
+                mapPowercafeReal[strKey].replycountall = mapPowercafeAll[strKey].replycountall;
+                mapPowercafeReal[strKey].allcountall = mapPowercafeAll[strKey].bodycountall + mapPowercafeAll[strKey].replycountall;
+                mapPowercafeReal[strKey].usercountall = mapUserAll[strKey].size();
+                mapUserReal.insert(strKey, QSet<QString>());
+            }
+            mapPowercafeReal[strKey].replycountreal++;
+            mapUserReal[strKey].insert((*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_article_id]].trimmed());
+        }
+
+        for (QMap<QString, stPowercafe>::iterator iterPos1 = mapPowercafeReal.begin(); iterPos1 != mapPowercafeReal.end(); iterPos1++)
+        {
+            iterPos1.value().usercountreal = mapUserReal[iterPos1.key()].size();
+            iterPos1.value().allcountreal = iterPos1.value().bodycountreal + iterPos1.value().replycountreal;
+        }
+        QList<stPowercafe> listPowercafe = mapPowercafeReal.values();
+
+        qSort(listPowercafe.begin(), listPowercafe.end(), isGreaterCountReal());
+        int rank = 1;
+        foreach (stPowercafe stpowercafe, listPowercafe)
+        {
+            stpowercafe.rank = rank++;
+            m_listMap.push_back(stpowercafe);
+        }
+    }
+}
+
+/*
+bool SPowercafe::STPowercafe::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery = "delete from powercafe where company_num = " + QString::number(_nCompany);
+    QSqlQuery query(_db);
+    if (query.exec(strQuery.toUtf8()) == false)
+    {
+        m_pSInitializer->insertLog(query.lastQuery());
+        m_pSInitializer->insertLog(query.lastError().text());
+        return false;
+    }
+    strQuery = "insert into powercafe (company_num,rank,community_num,community_id,bodycountall,replycountall,allcountall,usercountall,bodycountreal,replycountreal,allcountreal,usercountreal)"
+               " VALUES (:COMPANY_NUM,:RANK,:COMMUNITY_NUM,:COMMUNITY_ID,:BODY_ALL,:REPLY_ALL,:COUNT_ALL,:USER_ALL,:BODY_REAL,:REPLY_REAL,:ALL_REAL,:USER_REAL)";
+
+    query.clear();
+    query.prepare(strQuery.toUtf8());
+
+    foreach (const stPowercafe& stpowercafe, m_listMap)
+    {
+        query.bindValue(":COMPANY_NUM", _nCompany);
+        query.bindValue(":COMMUNITY_NUM", stpowercafe.community_num);
+        query.bindValue(":RANK", stpowercafe.rank);
+        query.bindValue(":COMMUNITY_ID", stpowercafe.community_id);
+        query.bindValue(":BODY_ALL", stpowercafe.bodycountall);
+        query.bindValue(":REPLY_ALL", stpowercafe.replycountall);
+        query.bindValue(":COUNT_ALL", stpowercafe.allcountall);
+        query.bindValue(":USER_ALL", stpowercafe.usercountall);
+        query.bindValue(":BODY_REAL", stpowercafe.bodycountreal);
+        query.bindValue(":REPLY_REAL", stpowercafe.replycountreal);
+        query.bindValue(":ALL_REAL", stpowercafe.allcountreal);
+        query.bindValue(":USER_REAL", stpowercafe.usercountreal);
+        if (query.exec() == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    strQuery = "update dbinfo set powercafecount = " + QString::number(m_listMap.size()) + " where company_num = "
+            + QString::number(_nCompany);
+    query.exec(strQuery);
+    return true;
+}
+*/
+
+bool SPowercafe::STPowercafe::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery = "delete from powercafe where company_num = " + QString::number(_nCompany);
+    QSqlQuery query(_db);
+    if (query.exec(strQuery.toUtf8()) == false)
+    {
+        m_pSInitializer->insertLog(query.lastQuery());
+        m_pSInitializer->insertLog(query.lastError().text());
+        return false;
+    }
+    strQuery = "insert into powercafe (company_num,rank,community_num,community_id,bodycountall,replycountall,allcountall,usercountall,"
+               "bodycountreal,replycountreal,allcountreal,usercountreal)"
+               " VALUES (";
+
+    query.clear();
+
+    foreach (const stPowercafe& stpowercafe, m_listMap)
+    {
+        QString str = strQuery;
+        str += QString::number(_nCompany) + ",";
+        str += QString::number(stpowercafe.rank) + ",";
+        str += QString::number(stpowercafe.community_num) + ",";
+        str += "'" + sqlString(stpowercafe.community_id) + "',";
+        str += QString::number(stpowercafe.bodycountall) + ",";
+        str += QString::number(stpowercafe.replycountall) + ",";
+        str += QString::number(stpowercafe.allcountall) + ",";
+        str += QString::number(stpowercafe.usercountall) + ",";
+        str += QString::number(stpowercafe.bodycountreal) + ",";
+        str += QString::number(stpowercafe.replycountreal) + ",";
+        str += QString::number(stpowercafe.allcountreal) + ",";
+        str += QString::number(stpowercafe.usercountreal) + ")";
+
+        if (query.exec(str.toUtf8()) == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    strQuery = "update dbinfo set powercafecount = " + QString::number(m_listMap.size()) + " where company_num = "
+            + QString::number(_nCompany);
+    query.exec(strQuery);
+    return true;
+}
+
+
+void SPowercafe::SStatsPowCafeRank::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();
+    QMap<QString, stStatsPowCafeRank> mapPowercafeAll;
+    for (QMap<QString, QStringList>::const_iterator iterPos = mapBody->constBegin(); iterPos != mapBody->constEnd(); iterPos++)
+    {
+        if (iterPos.value()[anColumn[SInitializer::E_DATA_platform_form]].trimmed() != "cafe")
+            continue;
+
+        QString strKey = iterPos.value()[anColumn[SInitializer::E_DATA_platform_id]].trimmed();
+        if (!mapPowercafeAll.contains(strKey))
+        {
+            mapPowercafeAll.insert(strKey, stStatsPowCafeRank());
+            mapPowercafeAll[strKey].community_id = iterPos.value()[anColumn[SInitializer::E_DATA_platform_id]].trimmed();
+            mapPowercafeAll[strKey].community_title = iterPos.value()[anColumn[SInitializer::E_DATA_platform_title]].trimmed();
+            mapPowercafeAll[strKey].subject = "articlecountall";
+        }
+        mapPowercafeAll[strKey].articlecountall++;
+    }
+
+    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++)
+        {
+            if (iterPos1.value()[anColumn[SInitializer::E_DATA_platform_form]].trimmed() != "cafe")
+                continue;
+
+            QString strKey = iterPos1.value()[anColumn[SInitializer::E_DATA_platform_id]].trimmed();
+            if (!mapPowercafeAll.contains(strKey))
+            {
+                mapPowercafeAll.insert(strKey, stStatsPowCafeRank());
+                mapPowercafeAll[strKey].community_id = iterPos1.value()[anColumn[SInitializer::E_DATA_platform_id]].trimmed();
+                mapPowercafeAll[strKey].community_title = iterPos1.value()[anColumn[SInitializer::E_DATA_platform_title]].trimmed();
+                mapPowercafeAll[strKey].subject = "articlecountall";
+            }
+            mapPowercafeAll[strKey].articlecountall++;
+        }
+    }
+
+    {
+        QList<stStatsPowCafeRank> listPowercafe = mapPowercafeAll.values();
+
+        qSort(listPowercafe.begin(), listPowercafe.end(), isGreaterCountAll());
+        int rank = 1;
+        foreach (stStatsPowCafeRank ststats, listPowercafe)
+        {
+            ststats.rank = rank++;
+            m_listMap.push_back(ststats);
+            if (rank > 10)
+                break;
+        }
+    }
+
+
+    for (QMap<int, stReal>::const_iterator iterPos = _mapCategory.constBegin(); iterPos != _mapCategory.constEnd(); iterPos++)
+    {
+        QMap<QString, stStatsPowCafeRank> mapPowercafeReal;
+        const stReal& streal = iterPos.value();
+
+        foreach (const QString& url, streal.m_setRealBodyUrl)
+        {
+            QString strKey = (*mapBody)[url][anColumn[SInitializer::E_DATA_platform_id]].trimmed();
+            if (!mapPowercafeReal.contains(strKey))
+            {
+                mapPowercafeReal.insert(strKey, stStatsPowCafeRank());
+                mapPowercafeReal[strKey].community_id = _datagroup.getstCommunity((*mapBody)[url])->id;
+                mapPowercafeReal[strKey].community_title = _datagroup.getstCommunity((*mapBody)[url])->title;
+                mapPowercafeReal[strKey].subject = "articlecountreal";
+            }
+            mapPowercafeReal[strKey].articlecountreal++;
+        }
+
+        for (QMap<QString, int>::const_iterator iterPos1 = streal.m_mapRealReplyUniqueUrl.begin(); iterPos1 != streal.m_mapRealReplyUniqueUrl.constEnd(); iterPos1++)
+        {
+            QString strKey = (*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_platform_id]].trimmed();
+            if (!mapPowercafeReal.contains(strKey))
+            {
+                mapPowercafeReal.insert(strKey, stStatsPowCafeRank());
+                mapPowercafeReal[strKey].community_id = _datagroup.getstCommunity((*mapReply)[iterPos1.key()][iterPos1.value()])->id;
+                mapPowercafeReal[strKey].community_title = _datagroup.getstCommunity((*mapReply)[iterPos1.key()][iterPos1.value()])->title;
+                mapPowercafeReal[strKey].subject = "aritclecountreal";
+            }
+            mapPowercafeReal[strKey].articlecountreal++;
+        }
+
+        QList<stStatsPowCafeRank> listPowercafe = mapPowercafeReal.values();
+        qSort(listPowercafe.begin(), listPowercafe.end(), isGreaterCountReal());
+        int rank = 1;
+        foreach (stStatsPowCafeRank ststats, listPowercafe)
+        {
+            ststats.rank = rank++;
+            m_listMap.push_back(ststats);
+            if (rank > 10)
+                break;
+        }
+    }
+}
+
+/*
+bool SPowercafe::SStatsPowCafeRank::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery = "delete from stats_pow_cafe_rank where company_num = " + QString::number(_nCompany);
+    QSqlQuery query(_db);
+    if (query.exec(strQuery.toUtf8()) == false)
+    {
+        m_pSInitializer->insertLog(query.lastQuery());
+        m_pSInitializer->insertLog(query.lastError().text());
+        return false;
+    }
+    strQuery = "insert into stats_pow_cafe_rank (community_id,community_title,articlecountall,articlecountreal,usercountreal,subject,rank,company_num)"
+            "VALUES (:community_id,:community_title,:articlecountall,:articlecountreal,:usercountreal,:subject,:rank,:company_num)";
+    query.clear();
+    query.prepare(strQuery.toUtf8());
+    foreach (const stStatsPowCafeRank& ststats, m_listMap)
+    {
+        query.bindValue(":community_id", ststats.community_id);
+        query.bindValue(":community_title", sqlString(ststats.community_title));
+        query.bindValue(":articlecountall", ststats.articlecountall);
+        query.bindValue(":articlecountreal", ststats.articlecountreal);
+        query.bindValue(":usercountreal", ststats.usercountreal);
+        query.bindValue(":subject", ststats.subject);
+        query.bindValue(":rank", ststats.rank);
+        query.bindValue(":company_num", _nCompany);
+        if (query.exec() == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    return true;
+}
+*/
+
+
+bool SPowercafe::SStatsPowCafeRank::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery = "delete from stats_pow_cafe_rank where company_num = " + QString::number(_nCompany);
+    QSqlQuery query(_db);
+    if (query.exec(strQuery.toUtf8()) == false)
+    {
+        m_pSInitializer->insertLog(query.lastQuery());
+        m_pSInitializer->insertLog(query.lastError().text());
+        return false;
+    }
+    strQuery = "insert into stats_pow_cafe_rank (community_id,community_title,articlecountall,articlecountreal,"
+               "usercountreal,subject,rank,company_num)"
+            "VALUES (";
+    query.clear();
+
+    foreach (const stStatsPowCafeRank& ststats, m_listMap)
+    {
+        QString str = strQuery;
+        str += "'" + sqlString(ststats.community_id) + "',";
+        str += "'" + sqlString(ststats.community_title) + "',";
+        str += QString::number(ststats.articlecountall) + ",";
+        str += QString::number(ststats.articlecountreal) + ",";
+        str += QString::number(ststats.usercountreal) + ",";
+        str += "'" + ststats.subject + "',";
+        str += QString::number(ststats.rank) + ",";
+        str += QString::number(_nCompany) + ")";
+
+        if (query.exec(str.toUtf8()) == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    return true;
+}
+
+
+
+void SPowercafe::SBodyPowercafeMap::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))
+            {
+                stBodyPowercafeMap stbody;
+                stbody.num = num++;
+                stbody.body_num = _datagroup.getstBodyNum(strUrl);
+                stbody.community_num = _datagroup.getstBody(strUrl)->community_num;
+                stbody.category_num = iterPos.key();
+                stbody.realin |= REAL_BODY;
+                m_listMap.append(stbody);
+                //_datagroup.addRealBodyCategory(strUrl, iterPos.key());
+                if (streal.m_mapRealReplyUniqueUrl.contains(strUrl))
+                {
+                    stbody.realin |= REAL_REPLY;
+                    /*
+                    foreach (int order, streal.m_mapRealReplyUniqueUrl.values(strUrl))
+                    {
+                        _datagroup.addRealReplyCategory(strUrl, order, iterPos.key());
+                    }
+                    */
+                }
+            }
+        }
+    }
+}
+
+
+void SPowercafe::SReplyPowercafeMap::makeTable(SDatagroup &_datagroup, const QMap<int, stReal> &_mapCategory)
+{
+    int num = 0;
+    for (QMap<int, stReal>::const_iterator iterPos = _mapCategory.constBegin(); iterPos != _mapCategory.constEnd(); iterPos++)
+    {
+        const stReal& streal = iterPos.value();
+        for (QMap<QString, int>::const_iterator iterPos1 = streal.m_mapRealReplyUniqueUrl.constBegin(); iterPos1 != streal.m_mapRealReplyUniqueUrl.end(); iterPos1++)
+        {
+            stReplyPowercafeMap streply;
+            streply.num = num++;
+            streply.body_num = _datagroup.getstBodyNum(iterPos1.key());
+            streply.category_num = iterPos.key();
+            streply.realin |= REAL_REPLY;
+            streply.community_num = _datagroup.getstReply(iterPos1.key(), iterPos1.value())->community_num;
+            streply.reply_num = _datagroup.getstReply(iterPos1.key(), iterPos1.value())->num;
+            m_listMap.append(streply);
+
+            /*
+            foreach (int order, streal.m_mapRealReplyUniqueUrl.values(strUrl))
+            {
+                _datagroup.addRealReplyCategory(strUrl, order, iterPos.key());
+            }
+            */
+        }
+    }
+}
+/*
+bool SPowercafe::SBodyPowercafeMap::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery = "truncate body_powercafe_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 = "insert into body_powercafe_map_" + QString::number(_nCompany) + "_update (num,category_num,community_num,body_num,realin)"
+            " values (:num,:category_num,:community_num,:body_num,:realin)";
+    query.clear();
+    query.prepare(strQuery.toUtf8());
+
+    foreach (const stBodyPowercafeMap& stmap, m_listMap)
+    {
+        query.bindValue(":num", stmap.num);
+        query.bindValue(":category_num", stmap.category_num);
+        query.bindValue(":community_num", stmap.community_num);
+        query.bindValue(":body_num", stmap.body_num);
+        query.bindValue(":realin", stmap.realin);
+        if (query.exec() == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    return true;
+}
+*/
+
+bool SPowercafe::SBodyPowercafeMap::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery = "truncate body_powercafe_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 = "insert into body_powercafe_map_" + QString::number(_nCompany)
+            + "_update (num,category_num,community_num,body_num,realin)"
+            " values (";
+    query.clear();
+
+    foreach (const stBodyPowercafeMap& stmap, m_listMap)
+    {
+        QString str = strQuery;
+        str += QString::number(stmap.num) + ",";
+        str += QString::number(stmap.category_num) + ",";
+        str += QString::number(stmap.community_num) + ",";
+        str += QString::number(stmap.body_num) + ",";
+        str += QString::number(stmap.realin) + ")";
+
+        if (query.exec(str.toUtf8()) == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    return true;
+}
+
+/*
+bool SPowercafe::SReplyPowercafeMap::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+
+    QString strQuery = "truncate reply_powercafe_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 = "insert into reply_powercafe_map_" + QString::number(_nCompany) + "_update (num,category_num,community_num,body_num,reply_num,realin)"
+            " values (:num,:category_num,:community_num,:body_num,:reply_num,:realin)";
+    query.clear();
+    query.prepare(strQuery.toUtf8());
+
+    foreach (const stReplyPowercafeMap& stmap, m_listMap)
+    {
+        query.bindValue(":num", stmap.num);
+        query.bindValue(":category_num", stmap.category_num);
+        query.bindValue(":community_num", stmap.community_num);
+        query.bindValue(":body_num", stmap.body_num);
+        query.bindValue(":realin", stmap.realin);
+        query.bindValue(":reply_num", stmap.reply_num);
+        if (query.exec() == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    return true;
+}
+*/
+
+
+bool SPowercafe::SReplyPowercafeMap::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+
+    QString strQuery = "truncate reply_powercafe_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 = "insert into reply_powercafe_map_" + QString::number(_nCompany)
+            + "_update (num,category_num,community_num,body_num,reply_num,realin)"
+            " values (";
+    query.clear();
+
+    foreach (const stReplyPowercafeMap& stmap, m_listMap)
+    {
+        QString str = strQuery;
+        str += QString::number(stmap.num) + ",";
+        str += QString::number(stmap.category_num) + ",";
+        str += QString::number(stmap.community_num) + ",";
+        str += QString::number(stmap.body_num) + ",";
+        str += QString::number(stmap.reply_num) + ",";
+        str += QString::number(stmap.realin) + ")";
+
+        if (query.exec(str.toUtf8()) == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    return true;
+}
+
+
+bool SPowercafe::SBodyPowercafeMap::changeTable(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery;
+    QSqlQuery query(_db);
+    strQuery = "RENAME TABLE ";
+    strQuery += "body_powercafe_map_" + QString::number(_nCompany) + " TO " + "body_powercafe_map_" + QString::number(_nCompany) + "_temp" + ",";
+    strQuery += "body_powercafe_map_" + QString::number(_nCompany) + "_update" + " TO " + "body_powercafe_map_" + QString::number(_nCompany) + ",";
+    strQuery += "body_powercafe_map_" + QString::number(_nCompany) + "_temp" + " TO " + "body_powercafe_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 SPowercafe::SReplyPowercafeMap::changeTable(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery;
+    QSqlQuery query(_db);
+    strQuery = "RENAME TABLE ";
+    strQuery += "reply_powercafe_map_" + QString::number(_nCompany) + " TO " + "reply_powercafe_map_" + QString::number(_nCompany) + "_temp" + ",";
+    strQuery += "reply_powercafe_map_" + QString::number(_nCompany) + "_update" + " TO " + "reply_powercafe_map_" + QString::number(_nCompany) + ",";
+    strQuery += "reply_powercafe_map_" + QString::number(_nCompany) + "_temp" + " TO " + "reply_powercafe_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;
+}

sfilterprocess/spowercafe.h

@@ -0,0 +1,164 @@
+#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 company_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;
+        stPowercafe():company_num(0), community_num(0), bodycountall(0), replycountall(0), allcountall(0), usercountall(0), bodycountreal(0),
+            replycountreal(0), allcountreal(0), usercountreal(0), rank(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;
+        stBodyPowercafeMap():num(0), body_num(0), community_num(0), category_num(0), realin(0){}
+    };
+
+    struct stReplyPowercafeMap
+    {
+        int num;
+        int reply_num;
+        int body_num;
+        int community_num;
+        int category_num;
+        int realin;
+        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);
+    };
+
+    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 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;
+        }
+    };
+
+    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;
+
+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
+

sfilterprocess/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
+

sfilterprocess/sspammer.cpp

@@ -0,0 +1,757 @@
+#include <QDebug>
+#include <QSqlDatabase>
+#include <QSqlQuery>
+#include <QSqlError>
+#include <QVariant>
+#include <QString>
+#include <QStringList>
+#include "sspammer.h"
+
+
+void SSpammer::setInitiaizer(SInitializer &_initializer)
+{
+    m_pSInitializer = &_initializer;
+    m_SBodySpammerMap.setInitiaizer(_initializer);
+    m_SReplySpammerMap.setInitiaizer(_initializer);
+    m_SStatsSpaSpammerRank.setInitiaizer(_initializer);
+    m_STSpammer.setInitiaizer(_initializer);
+}
+
+bool SSpammer::uploadData(int _companyNum)
+{
+    m_pSInitializer->insertLog("Start upload Spammer");
+
+    QSqlDatabase dbWeb = m_pSInitializer->getDatabase(SDBManager::E_DATABASE_WEB);
+    m_pSInitializer->updateWebDBInfoState(dbWeb, _companyNum, "Spammer (Start)");
+    if (!m_SBodySpammerMap.uploadData(dbWeb, _companyNum))
+    {
+        m_pSInitializer->insertLog("Fail to upload Spammer body map");
+        return false;
+    }
+    if (!m_SReplySpammerMap.uploadData(dbWeb, _companyNum))
+    {
+        m_pSInitializer->insertLog("Fail to upload Spammer reply map");
+        return false;
+    }
+    if (!m_SStatsSpaSpammerRank.uploadData(dbWeb, _companyNum))
+    {
+        m_pSInitializer->insertLog("Fail to upload stats_spa_spammer_rank");
+        return false;
+    }
+    if (!m_STSpammer.uploadData(dbWeb, _companyNum))
+    {
+        m_pSInitializer->insertLog("Fail to upload spammer");
+        return false;
+    }
+    m_pSInitializer->insertLog("End upload Spammer");
+    m_pSInitializer->updateWebDBInfoState(dbWeb, _companyNum, "Spammer (Finish)");
+
+    return true;
+}
+
+bool SSpammer::changeTable(int _companyNum)
+{
+    m_pSInitializer->insertLog("Start table change spammer");
+    QSqlDatabase dbWeb = m_pSInitializer->getDatabase(SDBManager::E_DATABASE_WEB);
+    if (!m_SBodySpammerMap.changeTable(dbWeb, _companyNum))
+    {
+        m_pSInitializer->insertLog("Fail to upload spammer body map");
+        return false;
+    }
+    if (!m_SReplySpammerMap.changeTable(dbWeb, _companyNum))
+    {
+        m_pSInitializer->insertLog("Fail to upload spammer reply map");
+        return false;
+    }
+    return true;
+
+}
+
+bool SSpammer::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;
+    qDebug() << "filtered size: " << vecData[SInitializer::E_ARTICLE_BODY].size();
+    qDebug() << "filtered size: " << vecData[SInitializer::E_ARTICLE_REPLY].size();
+    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 SSpammer::makeOverallCategory(int _categoryNum)
+{
+    return true;
+}
+
+bool SSpammer::makeTable(SDatagroup &_datagroup)
+{
+    m_pSInitializer->insertLog("Make spammer tables");
+    m_pSInitializer->insertLog("Make spammer spammer");
+    m_STSpammer.makeTable(_datagroup, m_mapCategory, m_setSpammer);
+    m_pSInitializer->insertLog("Make spammer stats_spa_spammer_rank tables");
+    m_SStatsSpaSpammerRank.makeTable(_datagroup, m_mapCategory);
+    m_pSInitializer->insertLog("Make spammer body tables");
+    m_SBodySpammerMap.makeTable(_datagroup, m_mapCategory, m_setSpammer);
+    m_pSInitializer->insertLog("Make spammer reply tables");
+    m_SReplySpammerMap.makeTable(_datagroup, m_mapCategory, m_setSpammer);
+    return true;
+}
+
+void SSpammer::STSpammer::makeTable(SDatagroup &_datagroup, const QMap<int, stReal> &_mapCategory, QSet<int> &setSpammer)
+{
+    const QMap<QString, QStringList>* mapBody = _datagroup.getmapBody();
+    const QMap<QString, QMap<int, QStringList> >* mapReply = _datagroup.getmapReply();
+    const int* anColumn = m_pSInitializer->getColumnIntArray();
+
+
+    for (QMap<int, stReal>::const_iterator iterPos = _mapCategory.constBegin(); iterPos != _mapCategory.constEnd(); iterPos++)
+    {
+        QMap<QString, stSpammerScore> mapScore;
+        const stReal& streal = iterPos.value();
+        foreach (const QString& _url, streal.m_setRealBodyUrl)
+        {
+            QString strKey = (*mapBody)[_url][anColumn[SInitializer::E_DATA_article_id]].trimmed() + ",";
+            strKey += (*mapBody)[_url][anColumn[SInitializer::E_DATA_platform_name]].trimmed() + ",";
+            strKey += (*mapBody)[_url][anColumn[SInitializer::E_DATA_platform_form]].trimmed();
+            if (!mapScore.contains(strKey))
+            {
+                mapScore.insert(strKey, stSpammerScore());
+                mapScore[strKey].id_num = _datagroup.getstBody(_url)->id_num;
+            }
+            mapScore[strKey].body++;
+            mapScore[strKey].nickname.insert((*mapBody)[_url][anColumn[SInitializer::E_DATA_article_nickname]].trimmed());
+        }
+
+        for (QMap<QString, int>::const_iterator iterPos1 = streal.m_mapRealReplyUniqueUrl.constBegin(); iterPos1 != streal.m_mapRealReplyUniqueUrl.constEnd(); iterPos1++)
+        {
+            QString strKey = (*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_article_id]].trimmed() + ",";
+            strKey += (*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_platform_name]].trimmed() + ",";
+            strKey += (*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_platform_form]].trimmed();
+            if (!mapScore.contains(strKey))
+            {
+                mapScore.insert(strKey, stSpammerScore());
+                mapScore[strKey].id_num = _datagroup.getstReply(iterPos1.key(), iterPos1.value())->id_num;
+            }
+            mapScore[strKey].reply++;
+            mapScore[strKey].nickname.insert((*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_article_nickname]].trimmed());
+        }
+
+
+        QList<stSpammer> listSpammer;
+
+        for (QMap<QString, stSpammerScore>::iterator iterPos1 = mapScore.begin(); iterPos1 != mapScore.end(); iterPos1++)
+        {
+            stSpammer stspammer;
+            stspammer.bodycount = iterPos1->body;
+            stspammer.replycount = iterPos1->reply;
+            stspammer.nicknamecount = iterPos1->nickname.size();
+            stspammer.id_num = iterPos1->id_num;
+            stspammer.id_id = iterPos1.key().split(",").at(0);
+            if (stspammer.bodycount > m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_BODY_COUNT_CUT] ||
+                    stspammer.replycount > m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_NICK_COUNT_CUT] ||
+                    iterPos1->nickname.size() > m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_NICK_COUNT_CUT])
+            {
+
+                stspammer.spammervalue = stspammer.bodycount * m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_BODY_COUNT_RATIO]
+                        + stspammer.replycount * m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_REPLY_COUNT_RATIO]
+                        + iterPos1->nickname.size() * m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_NICK_COUNT_RATIO];
+                listSpammer.push_back(stspammer);
+            }
+        }
+        qSort(listSpammer.begin(), listSpammer.end(), isGreaterSpammerValue());
+
+        int i = 1;
+
+        for (QList<stSpammer>::iterator iterPos1 = listSpammer.begin(); iterPos1 != listSpammer.end(); iterPos1++)
+        {
+            iterPos1->rank = i++;
+            setSpammer.insert(iterPos1->id_num);
+            m_listMap.push_back(*iterPos1);
+
+        }
+    }
+}
+
+/*
+bool SSpammer::STSpammer::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    //_db.transaction();
+    QString strQuery = "delete from spammer where company_num = " + QString::number(_nCompany);
+    QSqlQuery query(_db);
+    if (query.exec(strQuery.toUtf8()) == false)
+    {
+        m_pSInitializer->insertLog(query.lastQuery());
+        m_pSInitializer->insertLog(query.lastError().text());
+        return false;
+    }
+    //_db.commit();
+    //_db.transaction();
+    strQuery = "insert into spammer (rank,id_num,id_id,nicknamecount,bodycount,replycount,spammervalue,company_num) VALUES ("
+            ":rank,:id_num,:id_id,:nicknamecount,:bodycount,:replycount,:spammervalue,:company_num)";
+
+
+    query.clear();
+    query.prepare(strQuery.toUtf8());
+
+    foreach (const stSpammer& stspammer, m_listMap)
+    {
+        query.bindValue(":rank", stspammer.rank);
+        query.bindValue(":id_num", stspammer.id_num);
+        query.bindValue(":id_id", stspammer.id_id);
+        query.bindValue(":nicknamecount", stspammer.nicknamecount);
+        query.bindValue(":bodycount", stspammer.bodycount);
+        query.bindValue(":replycount", stspammer.replycount);
+        query.bindValue(":spammervalue", QString::number(stspammer.spammervalue, 'g', 3));
+        query.bindValue(":company_num", _nCompany);
+        if (query.exec() == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    //_db.commit();
+
+
+    strQuery = "update dbinfo set spammercount = " + QString::number(m_listMap.size()) + " where company_num = "
+            + QString::number(_nCompany);
+    query.exec(strQuery);
+
+
+    return true;
+}
+*/
+
+
+bool SSpammer::STSpammer::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    //_db.transaction();
+    QString strQuery = "delete from spammer where company_num = " + QString::number(_nCompany);
+    QSqlQuery query(_db);
+    if (query.exec(strQuery.toUtf8()) == false)
+    {
+        m_pSInitializer->insertLog(query.lastQuery());
+        m_pSInitializer->insertLog(query.lastError().text());
+        return false;
+    }
+    //_db.commit();
+    //_db.transaction();
+    strQuery = "insert into spammer (rank,id_num,id_id,nicknamecount,bodycount,replycount,spammervalue,company_num) VALUES (";
+
+    query.clear();
+
+    foreach (const stSpammer& stspammer, m_listMap)
+    {
+        QString str = strQuery;
+        str += QString::number(stspammer.rank) + ",";
+        str += QString::number(stspammer.id_num) + ",";
+        str += "'" + sqlString(stspammer.id_id) + "',";
+        str += QString::number(stspammer.nicknamecount) + ",";
+        str += QString::number(stspammer.bodycount) + ",";
+        str += QString::number(stspammer.replycount) + ",";
+        str += QString::number(stspammer.spammervalue, 'g', 3) + ",";
+        str += QString::number(_nCompany) + ")";
+
+        if (query.exec(str.toUtf8()) == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    //_db.commit();
+
+    strQuery = "update dbinfo set spammercount = " + QString::number(m_listMap.size()) + " where company_num = "
+            + QString::number(_nCompany);
+    query.exec(strQuery);
+
+    return true;
+}
+
+
+void SSpammer::SStatsSpaSpammerRank::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();
+
+    for (QMap<int, stReal>::const_iterator iterPos = _mapCategory.constBegin(); iterPos != _mapCategory.constEnd(); iterPos++)
+    {
+        QMap<QString, stSpammerScore> mapScore;
+        const stReal& streal = iterPos.value();
+        foreach (const QString& _url, streal.m_setRealBodyUrl)
+        {
+            QString strKey = (*mapBody)[_url][anColumn[SInitializer::E_DATA_article_id]].trimmed() + ",";
+            strKey += ((*mapBody)[_url][anColumn[SInitializer::E_DATA_platform_name]].trimmed() + ",");
+            strKey += (*mapBody)[_url][anColumn[SInitializer::E_DATA_platform_form]].trimmed();
+            if (!mapScore.contains(strKey))
+            {
+                mapScore.insert(strKey, stSpammerScore());
+                mapScore[strKey].id_num = _datagroup.getstBody(_url)->id_num;
+            }
+            mapScore[strKey].body++;
+            mapScore[strKey].nickname.insert((*mapBody)[_url][anColumn[SInitializer::E_DATA_article_nickname]].trimmed());
+        }
+
+        for (QMap<QString, int>::const_iterator iterPos1 = streal.m_mapRealReplyUniqueUrl.constBegin(); iterPos1 != streal.m_mapRealReplyUniqueUrl.constEnd(); iterPos1++)
+        {
+            QString strKey = (*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_article_id]].trimmed() + ",";
+            strKey += ((*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_platform_name]].trimmed() + ",");
+            strKey += (*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_platform_form]].trimmed();
+            if (!mapScore.contains(strKey))
+            {
+                mapScore.insert(strKey, stSpammerScore());
+                mapScore[strKey].id_num = _datagroup.getstBody(iterPos1.key())->id_num;
+            }
+            mapScore[strKey].reply++;
+            mapScore[strKey].nickname.insert((*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_article_nickname]].trimmed());
+        }
+
+
+        QList<stStatsSpaSpammerRank> listSpammer;
+
+        for (QMap<QString, stSpammerScore>::iterator iterPos1 = mapScore.begin(); iterPos1 != mapScore.end(); iterPos1++)
+        {
+            stStatsSpaSpammerRank ststats;
+            ststats.bodycount = iterPos1->body;
+            ststats.replycount = iterPos1->reply;
+            ststats.id_num = iterPos1->id_num;
+            ststats.nicknamecount = iterPos1->nickname.size();
+            ststats.id_id = iterPos1.key().split(",").at(0);
+            ststats.platformname_name = iterPos1.key().split(",").at(1);
+            ststats.subject = "spammervalue";
+            if (ststats.bodycount > m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_BODY_COUNT_CUT] ||
+                    ststats.replycount > m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_NICK_COUNT_CUT] ||
+                    iterPos1->nickname.size() > m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_NICK_COUNT_CUT])
+            {
+
+                ststats.spammervalue = ststats.bodycount * m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_BODY_COUNT_RATIO]
+                        + ststats.replycount * m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_REPLY_COUNT_RATIO]
+                        + iterPos1->nickname.size() * m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_NICK_COUNT_RATIO];
+                listSpammer.push_back(ststats);
+            }
+        }
+
+        qSort(listSpammer.begin(), listSpammer.end(), isGreaterSpammerValue());
+        QMap<QString, int> mapRank;
+
+        for (QList<stStatsSpaSpammerRank>::iterator iterPos1 = listSpammer.begin(); iterPos1 != listSpammer.end(); iterPos1++)
+        {
+            if (!mapRank.contains(iterPos1->platformname_name))
+                mapRank.insert(iterPos1->platformname_name, 1);
+
+            if (mapRank[iterPos1->platformname_name] <= 10)
+            {
+                iterPos1->rank = mapRank[iterPos1->platformname_name]++;
+                m_listMap.push_back(*iterPos1);
+            }
+        }
+    }
+}
+
+/*
+bool SSpammer::SStatsSpaSpammerRank::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    //_db.transaction();
+    QString strQuery = "delete from stats_spa_spammer_rank where company_num = " + QString::number(_nCompany);
+    QSqlQuery query(_db);
+    if (query.exec(strQuery.toUtf8()) == false)
+    {
+        m_pSInitializer->insertLog(query.lastQuery());
+        m_pSInitializer->insertLog(query.lastError().text());
+        return false;
+    }
+    //_db.commit();
+    //_db.transaction();
+    strQuery = "insert into stats_spa_spammer_rank (rank,id_num,id_id,nicknamecount,bodycount,replycount,spammervalue,company_num,platformname_name,subject) VALUES ("
+            ":rank,:id_num,:id_id,:nicknamecount,:bodycount,:replycount,:spammervalue,:company_num,:platformname_name,:subject)";
+
+    query.clear();
+    query.prepare(strQuery.toUtf8());
+
+    foreach (const stStatsSpaSpammerRank& ststats, m_listMap)
+    {
+        query.bindValue(":rank", ststats.rank);
+        query.bindValue(":id_num", ststats.id_num);
+        query.bindValue(":id_id", ststats.id_id);
+        query.bindValue(":nicknamecount", ststats.nicknamecount);
+        query.bindValue(":bodycount", ststats.bodycount);
+        query.bindValue(":replycount", ststats.replycount);
+        query.bindValue(":spammervalue", QString::number(ststats.spammervalue, 'g', 3));
+        query.bindValue(":company_num", _nCompany);
+        query.bindValue(":platformname_name", ststats.platformname_name);
+        query.bindValue(":subject", ststats.subject);
+        if (query.exec() == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    //_db.commit();
+    return true;
+}
+*/
+
+bool SSpammer::SStatsSpaSpammerRank::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    //_db.transaction();
+    QString strQuery = "delete from stats_spa_spammer_rank where company_num = " + QString::number(_nCompany);
+    QSqlQuery query(_db);
+    if (query.exec(strQuery.toUtf8()) == false)
+    {
+        m_pSInitializer->insertLog(query.lastQuery());
+        m_pSInitializer->insertLog(query.lastError().text());
+        return false;
+    }
+    //_db.commit();
+    //_db.transaction();
+    strQuery = "insert into stats_spa_spammer_rank (rank,id_num,id_id,nicknamecount,bodycount,replycount,"
+               "spammervalue,company_num,platformname_name,subject) VALUES (";
+    query.clear();
+
+    foreach (const stStatsSpaSpammerRank& ststats, m_listMap)
+    {
+        QString str = strQuery;
+        str += QString::number(ststats.rank) + ",";
+        str += QString::number(ststats.id_num) + ",";
+        str += "'" + sqlString(ststats.id_id) + "',";
+        str += QString::number(ststats.nicknamecount) + ",";
+        str += QString::number(ststats.bodycount) + ",";
+        str += QString::number(ststats.replycount) + ",";
+        str += QString::number(ststats.spammervalue, 'g', 3) + ",";
+        str += QString::number(_nCompany) + ",";
+        str += "'" + ststats.platformname_name + "',";
+        str += "'" + ststats.subject + "')";
+
+        if (query.exec(str.toUtf8()) == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    //_db.commit();
+    return true;
+}
+
+
+void SSpammer::SBodySpammerMap::makeTable(SDatagroup &_datagroup, const QMap<int, stReal> &_mapCategory, QSet<int>& setSpammer)
+{
+    int num = 1;
+    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))
+            {
+                if (!setSpammer.contains(_datagroup.getstBody(strUrl)->id_num))
+                    continue;
+
+                stBodySpammerMap stbody;
+                stbody.num = num++;
+                stbody.body_num = _datagroup.getstBodyNum(strUrl);
+                stbody.id_num = _datagroup.getstBody(strUrl)->id_num;
+                stbody.category_num = iterPos.key();
+                stbody.realin |= REAL_BODY;
+                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))
+            {
+                stBodySpammerMap stbody;
+                stbody.num = num++;
+                stbody.body_num = _datagroup.getstBodyNum(strUrl);
+                stbody.category_num = iterPos.key();
+                stbody.id_num = _datagroup.getstBody(strUrl)->id_num;
+                stbody.realin |= REAL_REPLY;
+                foreach (int order, streal.m_mapRealReplyUniqueUrl.values(strUrl))
+                {
+                    _datagroup.addRealReplyCategory(strUrl, order, iterPos.key());
+                }
+                m_listMap.append(stbody);
+            }
+            */
+        }
+    }
+}
+
+/*
+bool SSpammer::SBodySpammerMap::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery = "truncate body_spammer_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 = "insert into body_spammer_map_" + QString::number(_nCompany) + "_update (num,category_num,id_num,body_num,realin)"
+            " values (:num,:category_num,:id_num,:body_num,:realin)";
+    query.clear();
+    query.prepare(strQuery.toUtf8());
+
+    foreach (const stBodySpammerMap& stmap, m_listMap)
+    {
+        query.bindValue(":num", stmap.num);
+        query.bindValue(":category_num", stmap.category_num);
+        query.bindValue(":id_num", stmap.id_num);
+        query.bindValue(":body_num", stmap.body_num);
+        query.bindValue(":realin", stmap.realin);
+        if (query.exec() == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    return true;
+}
+*/
+
+bool SSpammer::SBodySpammerMap::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery = "truncate body_spammer_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 = "insert into body_spammer_map_" + QString::number(_nCompany) + "_update (num,category_num,id_num,body_num,realin)"
+            " values (";
+    query.clear();
+
+    foreach (const stBodySpammerMap& stmap, m_listMap)
+    {
+        QString str = strQuery;
+        str += QString::number(stmap.num) + ",";
+        str += QString::number(stmap.category_num) + ",";
+        str += QString::number(stmap.id_num) + ",";
+        str += QString::number(stmap.body_num) + ",";
+        str += QString::number(stmap.realin) + ")";
+        if (query.exec(str.toUtf8()) == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    return true;
+}
+
+
+void SSpammer::SReplySpammerMap::makeTable(SDatagroup &_datagroup, const QMap<int, stReal> &_mapCategory, QSet<int>& setSpammer)
+{
+    int num = 1;
+    //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)
+        {
+            for (QMap<QString, int>::const_iterator iterPos1 = streal.m_mapRealReplyUniqueUrl.constBegin(); iterPos1 != streal.m_mapRealReplyUniqueUrl.constEnd(); iterPos1++)
+            {
+                if (!setSpammer.contains(_datagroup.getstReply(iterPos1.key(), iterPos1.value())->id_num))
+                    continue;
+
+                stReplySpammerMap streply;
+                streply.num = num++;
+                streply.category_num = iterPos.key();
+                streply.body_num = _datagroup.getstReply(iterPos1.key(), iterPos1.value())->body_num;
+                streply.id_num = _datagroup.getstReply(iterPos1.key(), iterPos1.value())->id_num;
+                streply.reply_num = _datagroup.getstReply(iterPos1.key(), iterPos1.value())->num;
+                m_listMap.append(streply);
+            }
+
+            /*
+            if (streal.m_setRealAllUrl.contains(strUrl))
+            {
+                if (_datagroup.getstBody(strUrl)->reply_count == 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++)
+                {
+                    stReplySpammerMap streply;
+                    streply.num = num++;
+                    streply.category_num = iterPos.key();
+                    streply.body_num = iterPos1.value().body_num;
+                    streply.id_num = iterPos1.value().id_num;
+                    streply.reply_num = iterPos1.value().num;
+                    m_listMap.append(streply);
+                }
+            }
+            */
+        }
+    }
+}
+/*
+bool SSpammer::SReplySpammerMap::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery = "truncate reply_spammer_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 = "insert into reply_spammer_map_" + QString::number(_nCompany) + "_update (num,category_num,id_num,body_num,reply_num)"
+            " values (:num,:category_num,:id_num,:body_num,:reply_num)";
+    query.clear();
+    query.prepare(strQuery.toUtf8());
+
+    foreach (const stReplySpammerMap& stmap, m_listMap)
+    {
+        query.bindValue(":num", stmap.num);
+        query.bindValue(":category_num", stmap.category_num);
+        query.bindValue(":id_num", stmap.id_num);
+        query.bindValue(":body_num", stmap.body_num);
+        //query.bindValue(":realin", stmap.realin);
+        query.bindValue(":reply_num", stmap.reply_num);
+        if (query.exec() == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    return true;
+}
+*/
+
+bool SSpammer::SReplySpammerMap::uploadData(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery = "truncate reply_spammer_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 = "insert into reply_spammer_map_" + QString::number(_nCompany) + "_update (num,category_num,id_num,body_num,reply_num)"
+            " values (";
+    query.clear();
+
+    foreach (const stReplySpammerMap& stmap, m_listMap)
+    {
+        QString str = strQuery;
+        str += QString::number(stmap.num) + ",";
+        str += QString::number(stmap.category_num) + ",";
+        str += QString::number(stmap.id_num) + ",";
+        str += QString::number(stmap.body_num) + ",";
+        str += QString::number(stmap.reply_num) + ")";
+        if (query.exec(str.toUtf8()) == false)
+        {
+            m_pSInitializer->insertLog(query.lastQuery());
+            m_pSInitializer->insertLog(query.lastError().text());
+            return false;
+        }
+    }
+    return true;
+}
+
+bool SSpammer::SBodySpammerMap::changeTable(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery;
+    QSqlQuery query(_db);
+    strQuery = "RENAME TABLE ";
+    strQuery += "body_spammer_map_" + QString::number(_nCompany) + " TO " + "body_spammer_map_" + QString::number(_nCompany) + "_temp" + ",";
+    strQuery += "body_spammer_map_" + QString::number(_nCompany) + "_update" + " TO " + "body_spammer_map_" + QString::number(_nCompany) + ",";
+    strQuery += "body_spammer_map_" + QString::number(_nCompany) + "_temp" + " TO " + "body_spammer_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 SSpammer::SReplySpammerMap::changeTable(QSqlDatabase &_db, const int &_nCompany)
+{
+    QString strQuery;
+    QSqlQuery query(_db);
+    strQuery = "RENAME TABLE ";
+    strQuery += "reply_spammer_map_" + QString::number(_nCompany) + " TO " + "reply_spammer_map_" + QString::number(_nCompany) + "_temp" + ",";
+    strQuery += "reply_spammer_map_" + QString::number(_nCompany) + "_update" + " TO " + "reply_spammer_map_" + QString::number(_nCompany) + ",";
+    strQuery += "reply_spammer_map_" + QString::number(_nCompany) + "_temp" + " TO " + "reply_spammer_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;
+}

sfilterprocess/sspammer.h

@@ -0,0 +1,163 @@
+#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 company_num;
+        QString id_id;
+        int nicknamecount;
+        int bodycount;
+        int replycount;
+        double spammervalue;
+        int rank;
+        stSpammer():id_num(0), company_num(0), nicknamecount(0), bodycount(0), replycount(0), rank(0), spammervalue(0.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;
+        stBodySpammerMap():num(0), body_num(0), id_num(0), category_num(0), realin(0){}
+
+    };
+
+    struct stReplySpammerMap
+    {
+        int num;
+        int reply_num;
+        int body_num;
+        int id_num;
+        int category_num;
+        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){}
+    };
+
+    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);
+
+    };
+
+    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;
+        }
+    };
+
+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;
+
+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
+