clients/FilterProcess/sspammer.cpp

#include <QDebug>
#include <QSqlDatabase>
#include <QSqlQuery>
#include <QSqlError>
#include <QVariant>
#include <QString>
#include <QStringList>
#include <QDate>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QJsonValue>
#include <QSet>
#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);
    m_SStatsJson.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;
    }
    if (!m_SStatsJson.uploadData(dbWeb, _companyNum))
    {
        m_pSInitializer->insertLog("Fail to upload statsjson");
        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 change spammer body map");
        return false;
    }
    if (!m_SReplySpammerMap.changeTable(dbWeb, _companyNum))
    {
        m_pSInitializer->insertLog("Fail to change spammer reply map");
        return false;
    }
    if (!m_STSpammer.changeTable(dbWeb, _companyNum))
    {
        m_pSInitializer->insertLog("Fail to change spammer");
        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);
    m_pSInitializer->insertDebugLog(QString("Spammer Category: ") + m_pSInitializer->getCategoryName(_nCategory));
    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;
        }
        m_pSInitializer->insertDebugLog("Body: " + QString::number(vecData[SInitializer::E_ARTICLE_BODY].size()) + ", " +
                                           "Reply: " + QString::number(vecData[SInitializer::E_ARTICLE_REPLY].size()) + ", " +
                                           SService::convertJsonToStr(filter.m_nType, filter.m_vData.toString()));
    }
    stReal streal;
    m_pSInitializer->insertLog(QString("Category:") + m_pSInitializer->getCategoryName(_nCategory) + ",(" +
                               QString::number(vecData[SInitializer::E_ARTICLE_BODY].size()) + '/' + QString::number(vecData[SInitializer::E_ARTICLE_REPLY].size()) + ")" + "(Body/Reply)" );
    m_pSInitializer->insertDebugLog(QString("Category:") + m_pSInitializer->getCategoryName(_nCategory) + ",(" +
                               QString::number(vecData[SInitializer::E_ARTICLE_BODY].size()) + '/' + QString::number(vecData[SInitializer::E_ARTICLE_REPLY].size()) + ")" + "(Body/Reply)" );
    m_pSInitializer->insertDebugLog("");
    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)
{
    if (m_mapCategory.size() < 1)
        return true;

    stReal streal;
    for (QMap<int, stReal>::iterator iterPos = m_mapCategory.begin(); iterPos != m_mapCategory.end(); iterPos++ )
    {
        stReal& val = iterPos.value();
        foreach (const QString& _strurl, val.m_setRealBodyUrl )
            streal.m_setRealBodyUrl.insert(_strurl);
        foreach (const QString& _strurl, val.m_setRealAllUrl )
            streal.m_setRealAllUrl.insert(_strurl);

        for (QMap<QString, int>::iterator iterPos1 = val.m_mapRealReplyUniqueUrl.begin(); iterPos1 != val.m_mapRealReplyUniqueUrl.end();
             iterPos1++)
        {
            if (streal.m_mapRealReplyUniqueUrl.contains(iterPos1.key()) && streal.m_mapRealReplyUniqueUrl.values(iterPos1.key()).contains(iterPos1.value()))
                continue;
            else
                streal.m_mapRealReplyUniqueUrl.insertMulti(iterPos1.key(), iterPos1.value());
        }
    }

    m_mapCategory.insert(_categoryNum, streal);
    return true;
}

bool SSpammer::makeTable(SDatagroup &_datagroup)
{
    if (m_mapCategory.size() > 0)
    {
        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);
        m_pSInitializer->insertLog("Make sstatsjson table");
        m_SStatsJson.makeTable(_datagroup, m_mapCategory);
    }

    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() - 1;
            stspammer.id_num = iterPos1->id_num;
            stspammer.id_id = iterPos1.key().split(",").at(0);
            stspammer.category_num = iterPos.key();
            stspammer.platformname_name = iterPos1.key().split(",").at(1);
            stspammer.platformname_num = m_pSInitializer->getPlatformName(stspammer.platformname_name);
            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_" + 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;
    }
    //_db.commit();
    //_db.transaction();
    strQuery = "insert into spammer_" + QString::number(_nCompany) + "_update (rank,id_num,id_id,nicknamecount,bodycount,replycount,spammervalue,category_num,platformname_name,platformname_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(stspammer.category_num) + ",";
        str += "'" + stspammer.platformname_name + "',";
        str += QString::number(stspammer.platformname_num) + ")";

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


bool SSpammer::STSpammer::changeTable(QSqlDatabase &_db, const int &_nCompany)
{
    QString strQuery;
    QSqlQuery query(_db);
    strQuery = "RENAME TABLE ";
    strQuery += "spammer_" + QString::number(_nCompany) + " TO " + "spammer_" + QString::number(_nCompany) + "_temp" + ",";
    strQuery += "spammer_" + QString::number(_nCompany) + "_update" + " TO " + "spammer_" + QString::number(_nCompany) + ",";
    strQuery += "spammer_" + QString::number(_nCompany) + "_temp" + " TO " + "spammer_" + QString::number(_nCompany) + "_update";
    if (!query.exec(strQuery.toUtf8()))
    {
        m_pSInitializer->insertLog(query.lastQuery());
        m_pSInitializer->insertLog(query.lastError().text());
        return false;
    }
    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() - 1;
            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;
                stbody.platformname_num = _datagroup.getstBody(strUrl)->platformname_num;
                stbody.date = _datagroup.getstBody(strUrl)->date;
                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;
                stbody.platformname_num = _datagroup.getstBody(strUrl)->platformname_num;
                stbody.date = _datagroup.getstBody(strUrl)->date;

                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,date,platformname_num)"
            " 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) + ",";
        str += "'" + stmap.date + "',";
        str += QString::number(stmap.platformname_num) + ")";
        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;
                streply.body_date = _datagroup.getstBody(iterPos1.key())->date;
                m_listMap.append(streply);


                _datagroup.addRealReplyCategory(iterPos1.key(), iterPos1.value(), iterPos.key());

            }

            /*
            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,body_date)"
            " 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) + ",";
        str += "'" + stmap.body_date + "')";
        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;
}

void SSpammer::SStatsJson::makeTableBuzz(SDatagroup &_datagroup, const QMap<int, stReal> &_mapCategory)
{
    const QMap<QString, QStringList>* mapBody = _datagroup.getmapBody();
    const QMap<QString, QMap<int, QStringList> >* mapReply = _datagroup.getmapReply();
    const int* anColumn = m_pSInitializer->getColumnIntArray();

    QDate dateStart(2100,1,1),dateEnd(2000,1,1);
    QDate dateStartBody(2100,1,1),dateEndBody(2000,1,1);
    QDate dateStartReply(2100,1,1),dateEndReply(2000,1,1);

    QList<stBuzzy> listBuzzy;
    stReal allCategory;
    // filtered
    {
        for (QMap<int, stReal>::const_iterator iterPos = _mapCategory.constBegin(); iterPos != _mapCategory.constEnd(); iterPos++)
        {
            stBuzzy stbuzzy;
            stbuzzy.m_nCategory = iterPos.key();
            const stReal &streal = iterPos.value();
            foreach (const QString& strUrl, streal.m_setRealBodyUrl)
            {
                allCategory.m_setRealBodyUrl.insert(strUrl);
                allCategory.m_setRealAllUrl.insert(strUrl);
                QDate date = QDateTime::fromString((*mapBody)[strUrl.trimmed()][anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd HH:mm:ss").date();
                //if (date.isNull())
                //    date = QDateTime::fromString((*mapBody)[strUrl.trimmed()][anColumn[SInitializer::E_DATA_article_date]].trimmed(), "yyyy-MM-dd HH:mm:ss").date();
                if (date.year() == 1990)
                    continue;
                dateStart = (date < dateStart ) ? date : dateStart;
                dateEnd = (date > dateEnd ) ? date : dateEnd;
                dateStartBody = (date < dateStartBody ) ? date : dateStartBody;
                dateEndBody = (date > dateEndBody ) ? date : dateEndBody;


                if (stbuzzy.m_mapBodyBuzz.contains(date))
                    stbuzzy.m_mapBodyBuzz[date]++;
                else
                    stbuzzy.m_mapBodyBuzz.insert(date, 1);
            }

            for (QMap<QString, int>::const_iterator iterPos1 = streal.m_mapRealReplyUniqueUrl.constBegin(); iterPos1 != streal.m_mapRealReplyUniqueUrl.constEnd(); iterPos1++)
            {
                const QStringList &slReply = (*mapReply)[iterPos1.key()][iterPos1.value()];
                if (!allCategory.m_mapRealReplyUniqueUrl.contains(iterPos1.key()) || !allCategory.m_mapRealReplyUniqueUrl.values(iterPos1.key()).contains(iterPos1.value()))
                    allCategory.m_mapRealReplyUniqueUrl.insertMulti(iterPos1.key(), iterPos1.value());
                allCategory.m_setRealAllUrl.insert(iterPos1.key());

                QDate date = QDateTime::fromString(slReply[anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd HH:mm:ss").date();
                if (date.year() == 1990)
                    continue;
                dateStart = (date < dateStart ) ? date : dateStart;
                dateEnd = (date > dateEnd ) ? date : dateEnd;
                dateStartReply = (date < dateStartReply ) ? date : dateStartReply;
                dateEndReply = (date > dateEndReply ) ? date : dateEndReply;

                if (stbuzzy.m_mapReplyBuzz.contains(date))
                    stbuzzy.m_mapReplyBuzz[date]++;
                else
                    stbuzzy.m_mapReplyBuzz.insert(date, 1);
            }

            listBuzzy.append(stbuzzy);
        }
    }
    //all filtered category
    {
        stBuzzy stbuzzy;
        stbuzzy.m_nCategory = -1;
        foreach (const QString& strUrl, allCategory.m_setRealBodyUrl)
        {
            QDate date = QDateTime::fromString((*mapBody)[strUrl.trimmed()][anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd HH:mm:ss").date();
            if (date.year() == 1990)
                continue;

            if (stbuzzy.m_mapBodyBuzz.contains(date))
                stbuzzy.m_mapBodyBuzz[date]++;
            else
                stbuzzy.m_mapBodyBuzz.insert(date, 1);
        }

        for (QMap<QString, int>::const_iterator iterPos1 = allCategory.m_mapRealReplyUniqueUrl.constBegin(); iterPos1 != allCategory.m_mapRealReplyUniqueUrl.constEnd(); iterPos1++)
        {
            const QStringList &slReply = (*mapReply)[iterPos1.key()][iterPos1.value()];
            QDate date = QDateTime::fromString(slReply[anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd HH:mm:ss").date();
            if (date.year() == 1990)
                continue;

            if (stbuzzy.m_mapReplyBuzz.contains(date))
                stbuzzy.m_mapReplyBuzz[date]++;
            else
                stbuzzy.m_mapReplyBuzz.insert(date, 1);
        }
        listBuzzy.append(stbuzzy);
    }


    //all buzzy
    {
        stBuzzy stbuzzy;
        stbuzzy.m_nCategory = 0;
        for (QMap<QString, QStringList>::const_iterator iterPos = mapBody->constBegin(); iterPos != mapBody->constEnd(); iterPos++)
        {
            QDate date = QDateTime::fromString(iterPos.value()[anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd HH:mm:ss").date();
            if (date.year() == 1990)
                continue;

            if (stbuzzy.m_mapBodyBuzz.contains(date))
                stbuzzy.m_mapBodyBuzz[date]++;
            else
                stbuzzy.m_mapBodyBuzz.insert(date, 1);
        }

        for (QMap<QString, QMap<int, QStringList> >::const_iterator iterPos = mapReply->constBegin(); iterPos != mapReply->constEnd(); iterPos++)
        {
            for (QMap<int, QStringList>::const_iterator iterPos1 = iterPos.value().constBegin(); iterPos1 != iterPos.value().constEnd(); iterPos1++)
            {
                QDate date = QDateTime::fromString(iterPos1.value()[anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd HH:mm:ss").date();
                if (date.year() == 1990)
                    continue;

                if (stbuzzy.m_mapReplyBuzz.contains(date))
                    stbuzzy.m_mapReplyBuzz[date]++;
                else
                    stbuzzy.m_mapReplyBuzz.insert(date, 1);
            }
        }
        listBuzzy.append(stbuzzy);
    }

    int nTotalCount = 0, nTotalBodyCount = 0, nTotalReplyCount = 0;

    {
        foreach (const QString& strUrl, allCategory.m_setRealAllUrl)
        {
            nTotalBodyCount++;
            nTotalReplyCount += (*mapReply)[strUrl].size();
        }
        nTotalCount = nTotalBodyCount + nTotalReplyCount;
    }


    {
        QJsonArray jsArrayAll;
        QJsonArray jsArrayReply;
        QJsonArray jsArrayBody;

        foreach (const stBuzzy &stbuzzy, listBuzzy)
        {
            QJsonArray jsValueAll;
            QJsonArray jsValueBody;
            QJsonArray jsValueReply;

            for (QDate i = dateStart; i <= dateEnd; i = i.addDays(1))
            {
                QJsonObject jsoBody;
                QJsonObject jsoAll;
                QJsonObject jsoReply;

                jsoAll["date"] = jsoReply["date"] = jsoBody["date"] = i.toString("yyyyMMdd");
                jsoBody["count"] = stbuzzy.m_mapBodyBuzz[i];
                jsoReply["count"] = stbuzzy.m_mapReplyBuzz[i];
                jsoAll["count"] = stbuzzy.m_mapBodyBuzz[i] + stbuzzy.m_mapReplyBuzz[i];

                jsValueAll.append(jsoAll);
                jsValueBody.append(jsoBody);
                jsValueReply.append(jsoReply);
            }

            QJsonObject jsNameReply;
            QJsonObject jsNameAll;
            QJsonObject jsNameBody;

            if (stbuzzy.m_nCategory > 0)
                jsNameReply["name"] = jsNameBody["name"] = jsNameAll["name"] = m_pSInitializer->getCategoryName(stbuzzy.m_nCategory);
            else if (stbuzzy.m_nCategory == 0)
                jsNameReply["name"] = jsNameBody["name"] = jsNameAll["name"] = "ALL";
            else
                jsNameReply["name"] = jsNameBody["name"] = jsNameAll["name"] = "ALLCATEGORY";

            jsNameAll["value"] = jsValueAll;
            jsNameBody["value"] = jsValueBody;
            jsNameReply["value"] = jsValueReply;

            jsArrayAll.append(jsNameAll);
            jsArrayBody.append(jsNameBody);
            jsArrayReply.append(jsNameReply);
        }
        stStatsJson stbodybuzz;
        stStatsJson streplybuzz;
        stStatsJson stallbuzz;

        stallbuzz.title = streplybuzz.title = stbodybuzz.title = "buzz";

        stbodybuzz.subtitle = "body";
        streplybuzz.subtitle = "reply";
        stallbuzz.subtitle = "all";

        QJsonObject jobjAll;
        QJsonObject jobjBody;
        QJsonObject jobjReply;

        jobjAll["data"] = jsArrayAll;
        jobjBody["data"] = jsArrayBody;
        jobjReply["data"] = jsArrayReply;

        jobjAll["mindate"] = dateStart.toString("yyyy.MM.dd");
        jobjBody["mindate"] = dateStartBody.toString("yyyy.MM.dd");
        jobjReply["mindate"] = dateStartReply.toString("yyyy.MM.dd");

        jobjAll["maxdate"] = dateEnd.toString("yyyy.MM.dd");
        jobjBody["maxdate"] = dateEndBody.toString("yyyy.MM.dd");
        jobjReply["maxdate"] = dateEndReply.toString("yyyy.MM.dd");

        jobjAll["totalcount"] = nTotalCount;
        jobjBody["totalcount"] = nTotalBodyCount;
        jobjReply["totalcount"] = nTotalReplyCount;

        QJsonDocument jdAll(jobjAll);
        QJsonDocument jdBody(jobjBody);
        QJsonDocument jdReply(jobjReply);

        stbodybuzz.jdata = jdBody.toJson(QJsonDocument::Compact);
        streplybuzz.jdata = jdReply.toJson(QJsonDocument::Compact);
        stallbuzz.jdata = jdAll.toJson(QJsonDocument::Compact);

        stallbuzz.platformname_num = stbodybuzz.platformname_num = streplybuzz.platformname_num = 1;
        m_listMap.append(stbodybuzz);
        m_listMap.append(streplybuzz);
        m_listMap.append(stallbuzz);
    }

    /*

    {
        for (QDate i = dateStart; i <= dateEnd; i = i.addDays(1))
        {
            //body
            stStatsJson stbodybuzz;
            stStatsJson streplybuzz;
            stStatsJson stallbuzz;
            foreach (const stBuzzy& stbuzzy, listBuzzy)
            {
                if (stbuzzy.m_mapBodyBuzz.contains(i))
                {
                    stbodybuzz.category[stbuzzy.m_nCategory] = stbuzzy.m_mapBodyBuzz[i];
                    stallbuzz.category[stbuzzy.m_nCategory] += stbuzzy.m_mapBodyBuzz[i];
                }

                if (stbuzzy.m_mapReplyBuzz.contains(i))
                {
                    streplybuzz.category[stbuzzy.m_nCategory] = stbuzzy.m_mapReplyBuzz[i];
                    stallbuzz.category[stbuzzy.m_nCategory] += stbuzzy.m_mapReplyBuzz[i];
                }
            }
            stallbuzz.date = streplybuzz.date = stbodybuzz.date = i;
            stbodybuzz.subtitle = "body";
            streplybuzz.subtitle = "reply";
            stallbuzz.subtitle = "all";
            m_listMap.append(stallbuzz);
            m_listMap.append(stbodybuzz);
            m_listMap.append(streplybuzz);
        }
    }
    */
}

void SSpammer::SStatsJson::makeTableRank(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();

    stReal allCategory;

    for (QMap<int, stReal>::const_iterator iterPos = _mapCategory.constBegin(); iterPos != _mapCategory.constEnd(); iterPos++)
    {
        QMap<QString, stSpammerScore> mapScore;
        const stReal& streal = iterPos.value();
        QDate dateStart(2030, 1, 1);
        QDate dateEnd(2000, 1, 1);

        foreach (const QString& _url, streal.m_setRealBodyUrl)
        {
            allCategory.m_setRealBodyUrl.insert(_url);
            allCategory.m_setRealAllUrl.insert(_url);

            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());
            QDate dateThis = QDateTime::fromString((*mapBody)[_url][anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd hh:mm:ss").date();
            if (dateThis.isValid() && dateThis.year() > 1990)
            {
                dateStart = (dateStart < dateThis) ? dateStart : dateThis;
                dateEnd = (dateEnd > dateThis) ? dateEnd : dateThis;
            }
        }

        for (QMap<QString, int>::const_iterator iterPos1 = streal.m_mapRealReplyUniqueUrl.constBegin(); iterPos1 != streal.m_mapRealReplyUniqueUrl.constEnd(); iterPos1++)
        {
            allCategory.m_setRealAllUrl.insert(iterPos1.key());
            if (!allCategory.m_mapRealReplyUniqueUrl.contains(iterPos1.key()) || !allCategory.m_mapRealReplyUniqueUrl.values(iterPos1.key()).contains(iterPos1.value()))
                allCategory.m_mapRealReplyUniqueUrl.insertMulti(iterPos1.key(), iterPos1.value());
            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());
            QDate dateThis = QDateTime::fromString((*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd hh:mm:ss").date();
            if (dateThis.isValid() && dateThis.year() > 1990)
            {
                dateStart = (dateStart < dateThis) ? dateStart : dateThis;
                dateEnd = (dateEnd > dateThis) ? dateEnd : dateThis;
            }
        }

        //QList<stSpammerRank> listSpammer;
        QMap<int, stSpammerRank> mapSpammer;
        for (QMap<QString, stSpammerScore>::iterator iterPos1 = mapScore.begin(); iterPos1 != mapScore.end(); iterPos1++)
        {
            if (iterPos1->body >= m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_BODY_COUNT_CUT] ||
                    iterPos1->reply >= m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_NICK_COUNT_CUT] ||
                    iterPos1->nickname.size() >= m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_NICK_COUNT_CUT])
            {
                double value = iterPos1->body * m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_BODY_COUNT_RATIO]
                        + iterPos1->reply * m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_REPLY_COUNT_RATIO]
                        + iterPos1->nickname.size() * m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_NICK_COUNT_RATIO];
                stSpammerRank rank;
                rank.value = value;
                rank.id = iterPos1.key().split(",").at(0);
                rank.platformform_num = m_pSInitializer->getPlatformName(iterPos1.key().split(",").at(1));
                rank.id_num = iterPos1.value().id_num;
                mapSpammer.insertMulti(rank.platformform_num, rank);
            }
        }

        QList<int> keys = mapSpammer.keys().toSet().toList();

        QJsonArray jsonArray;
        stStatsJson stjsonRank;
        {
            stjsonRank.category_num = iterPos.key();
            stjsonRank.servicenum = 3;
            stjsonRank.title = "rank";
            stjsonRank.subtitle = "";
            stjsonRank.platformname_num = 1;
        }
        int nTotalCount = 0;

        for (QList<int>::iterator iterPos1 = keys.begin(); iterPos1 != keys.end(); iterPos1++)
        {
            QList<stSpammerRank> values = mapSpammer.values(*iterPos1);
            qSort(values.begin(), values.end(), isGreaterSpammerValue());
            int nRankLimit = (values.size() <= 10) ? values.size() : 10;
            QJsonObject jsonObj;
            jsonObj["platformname_num"] = *iterPos1;
            QJsonArray jsonSubArray;
            for (int i = 0; i < nRankLimit; i++)
            {
                QJsonObject jsonSubObj;
                jsonSubObj["rank"] = i + 1;
                jsonSubObj["value"] = values.at(i).value;
                jsonSubObj["id"] = values.at(i).id;
                jsonSubObj["id_num"] = values.at(i).id_num;
                jsonSubArray.append(jsonSubObj);
            }
            jsonObj["data"] = jsonSubArray;
            jsonArray.append(jsonObj);

            nTotalCount += values.size();
        }
        QJsonObject jObj;
        jObj["data"] = jsonArray;
        jObj["mindate"] = dateStart.toString("yyyy.MM.dd");
        jObj["maxdate"] = dateEnd.toString("yyyy.MM.dd");
        jObj["totalcount"] = nTotalCount;
        QJsonDocument jsonDoc(jObj);
        stjsonRank.jdata = jsonDoc.toJson();
        m_listMap.append(stjsonRank);
    }


    //all filtered Category
    {
        QMap<QString, stSpammerScore> mapScore;
        const stReal& streal = allCategory;
        QDate dateStart(2030, 1, 1);
        QDate dateEnd(2000, 1, 1);

        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());
            QDate dateThis = QDateTime::fromString((*mapBody)[_url][anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd hh:mm:ss").date();
            if (dateThis.isValid() && dateThis.year() > 1990)
            {
                dateStart = (dateStart < dateThis) ? dateStart : dateThis;
                dateEnd = (dateEnd > dateThis) ? dateEnd : dateThis;
            }
        }

        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());
            QDate dateThis = QDateTime::fromString((*mapReply)[iterPos1.key()][iterPos1.value()][anColumn[SInitializer::E_DATA_article_date]].trimmed().replace("T", " "), "yyyy-MM-dd hh:mm:ss").date();
            if (dateThis.isValid() && dateThis.year() > 1990)
            {
                dateStart = (dateStart < dateThis) ? dateStart : dateThis;
                dateEnd = (dateEnd > dateThis) ? dateEnd : dateThis;
            }
        }

        //QList<stSpammerRank> listSpammer;
        QMap<int, stSpammerRank> mapSpammer;
        for (QMap<QString, stSpammerScore>::iterator iterPos1 = mapScore.begin(); iterPos1 != mapScore.end(); iterPos1++)
        {
            if (iterPos1->body >= m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_BODY_COUNT_CUT] ||
                    iterPos1->reply >= m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_NICK_COUNT_CUT] ||
                    iterPos1->nickname.size() >= m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_NICK_COUNT_CUT])
            {
                double value = iterPos1->body * m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_BODY_COUNT_RATIO]
                        + iterPos1->reply * m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_REPLY_COUNT_RATIO]
                        + iterPos1->nickname.size() * m_pSInitializer->getSpammerParam()[SInitializer::E_SPAMER_NICK_COUNT_RATIO];
                stSpammerRank rank;
                rank.value = value;
                rank.id = iterPos1.key().split(",").at(0);
                rank.platformform_num = m_pSInitializer->getPlatformName(iterPos1.key().split(",").at(1));
                rank.id_num = iterPos1.value().id_num;
                mapSpammer.insertMulti(rank.platformform_num, rank);
            }
        }

        QList<int> keys = mapSpammer.keys().toSet().toList();

        QJsonArray jsonArray;
        stStatsJson stjsonRank;
        {
            stjsonRank.category_num = -1;
            stjsonRank.servicenum = 3;
            stjsonRank.title = "rank";
            stjsonRank.subtitle = "";
            stjsonRank.platformname_num = 1;
        }
        int nTotalCount = 0;

        for (QList<int>::iterator iterPos1 = keys.begin(); iterPos1 != keys.end(); iterPos1++)
        {
            QList<stSpammerRank> values = mapSpammer.values(*iterPos1);
            qSort(values.begin(), values.end(), isGreaterSpammerValue());
            int nRankLimit = (values.size() <= 10) ? values.size() : 10;
            QJsonObject jsonObj;
            jsonObj["platformname_num"] = *iterPos1;
            QJsonArray jsonSubArray;
            for (int i = 0; i < nRankLimit; i++)
            {
                QJsonObject jsonSubObj;
                jsonSubObj["rank"] = i + 1;
                jsonSubObj["value"] = values.at(i).value;
                jsonSubObj["id"] = values.at(i).id;
                jsonSubObj["id_num"] = values.at(i).id_num;
                jsonSubArray.append(jsonSubObj);
            }
            jsonObj["data"] = jsonSubArray;
            jsonArray.append(jsonObj);

            nTotalCount += values.size();
        }
        QJsonObject jObj;
        jObj["data"] = jsonArray;
        jObj["mindate"] = dateStart.toString("yyyy.MM.dd");
        jObj["maxdate"] = dateEnd.toString("yyyy.MM.dd");
        jObj["totalcount"] = nTotalCount;
        QJsonDocument jsonDoc(jObj);
        stjsonRank.jdata = jsonDoc.toJson();
        m_listMap.append(stjsonRank);
    }
}


void SSpammer::SStatsJson::makeTable(SDatagroup &_datagroup, const QMap<int, stReal> &_mapCategory)
{
    makeTableBuzz(_datagroup, _mapCategory);
    makeTableRank(_datagroup, _mapCategory);
}


bool SSpammer::SStatsJson::uploadData(QSqlDatabase &_db, const int &_nCompany)
{
    QSqlQuery query(_db);
    {
        QString strQuery = "delete from stats_json where company_num = " + QString::number(_nCompany) + " and servicenum = 3";
        if (!query.exec(strQuery.toUtf8()))
        {
            m_pSInitializer->insertLog(query.lastQuery());
            m_pSInitializer->insertLog(query.lastError().text());
            return false;
        }
    }

    foreach (const stStatsJson& ststats, m_listMap)
    {
        QString strQuery = "insert into stats_json (company_num, servicenum, title, subtitle, category_num, platformname_num, jdata) values (";
        strQuery += QString::number(_nCompany) + ",";
        strQuery += QString::number(ststats.servicenum) + ",";
        strQuery += "'" + ststats.title + "',";
        strQuery += "'" + ststats.subtitle + "',";
        strQuery += QString::number(ststats.category_num) + ",";
        strQuery += QString::number(ststats.platformname_num) + ",";
        strQuery += "'" + ststats.jdata +"')";

        if (!query.exec(strQuery.toUtf8()))
        {
            m_pSInitializer->insertLog(query.lastQuery());
            m_pSInitializer->insertLog(query.lastError().text());
            return false;
        }
    }
    return true;
}