SpeedNumCube/sncprojects/lib/SNCCube/formcube.cpp

#include "formcube.h"
#include "ui_formcube.h"
#include "dialoginputnumseg.h"
#include "dialogsettypefilter.h"
#include "dialogsetvaluefilter.h"
#include "dialogsetcombofilter.h"
#include "dialogselectsegment.h"
#include "dialogsetextractmethod.h"
#include "dialogsetsegment.h"
#include "dialogsetexportregiontype.h"
#include "dialogfilecompare.h"
#include "dialogexportbatchset.h"
#include "SNCDataBase.h"
#include "dialogprefile.h"
#include "dialogselectsegment2.h"

FormCube::FormCube(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::FormCube)
{
    ui->setupUi(this);
    initAD();
    initListView();
    createPopmenu();
    initButton();
    fileImportProxy = 0;
    outOrder = 0;
    numberProcess = 0;
    numberCreate = 0;
    numberCopy = 0;/**/
}

FormCube::~FormCube()
{
    //delete this->sourceModel;
    ad->abort();
    ad->wait();
    for(int i=0;i<buttons.size();i++)
    {
        delete buttons[i];
    }
    delete cacheViewSource;
    delete cacheViewDest;
    delete ddListView;
    delete ad;
    delete menuPopup;
    delete ui;

}

void FormCube::dragEnterEvent(QDragEnterEvent *event)
{

    if(cacheViewSource->isVisible())
    {
        cacheViewSource->setVisible(false);
        ddListView->setVisible(true);
    }
}

void FormCube::on_inputnumsegPB_clicked()
{
    if(!checkThreadFinished())
        return ;
    buildFromInputSegment(); ;
}
void FormCube::on_importSegmentsPB_clicked()
{
    if(!checkThreadFinished())
        return ;
    buildFromImportSegment();
}

void FormCube::on_importFilePB_clicked()
{
//    if(!checkThreadFinished())
//        return ;
//    buildFromFile(NumberFromFileImport);
}
void FormCube::on_extractPB_clicked()
{
    /*if(!checkThreadFinished())
        return ;
    buildFromExtract();*/

}
void FormCube::on_pastePB_clicked()
{
    if(!checkThreadFinished())
        return ;
    buildFromPaste();
}

void FormCube::slot_upbycomboPB_clicked()
{
    if(!checkThreadFinished())
        return ;
    moveNumberByCombo(destModel,sourceModel,UpDirection);
}
void FormCube::slot_downbycomboPB_clicked()
{
    if(!checkThreadFinished())
        return ;
    moveNumberByCombo(sourceModel,destModel,DownDirection);
}
void FormCube::on_clearoriPB_clicked()
{
    if(!checkThreadFinished())
        return ;
    clearNumberListModel(sourceModel);
}
void FormCube::on_cleardestPB_clicked()
{
    if(!checkThreadFinished())
        return ;
    clearNumberListModel(destModel);
}

void FormCube::slot_downbyallPB_clicked()
{
    if(!checkThreadFinished())
        return ;
    moveNumerByAll(sourceModel,destModel,DownDirection);
}
void FormCube::slot_upbyallPB_clicked()
{
    if(!checkThreadFinished())
        return ;
    moveNumerByAll(destModel,sourceModel,UpDirection);
}
void FormCube::slot_downbytypePB_clicked()
{
    if(!checkThreadFinished())
        return ;
    moveNumberByType(sourceModel,destModel,DownDirection);
}
void FormCube::slot_upbytypePB_clicked()
{
    if(!checkThreadFinished())
        return ;
    moveNumberByType(destModel,sourceModel,UpDirection);
}
void FormCube::slot_downbyvaluePB_clicked()
{
    if(!checkThreadFinished())
        return ;
    moveNumberByValue(sourceModel,destModel,DownDirection);
}
void FormCube::slot_upbyvaluePB_clicked()
{
    if(!checkThreadFinished())
        return ;
    moveNumberByValue(destModel,sourceModel,UpDirection);
}
void FormCube::on_exportByBatchPB_clicked()
{
    if(!checkThreadFinished())
        return ;
    if(ui->sourceRb->isChecked())
    {
        modelType = SourceModel;
        exportNumbersByBatch(sourceModel);
    }
    else
    {
        modelType = DestModel;
        exportNumbersByBatch(destModel);
    }

}

void FormCube::on_exportByCorpPB_clicked()
{
    if(!checkThreadFinished())
        return ;
    if(ui->sourceRb->isChecked())
    {
        modelType = SourceModel;
        exportNumbersByCorp(sourceModel);
    }
    else
    {
        modelType = DestModel;
        exportNumbersByCorp(destModel);
    }
}
void FormCube::on_exportByALLPB_clicked()
{
    if(!checkThreadFinished())
        return ;
    if(ui->sourceRb->isChecked())
    {
        modelType = SourceModel;
        exportNumbersByALL(sourceModel);
    }
    else
    {
        modelType = DestModel;
        exportNumbersByALL(destModel);
    }
}
void FormCube::on_exportBySegmentPB_clicked()
{
    if(!checkThreadFinished())
        return ;
    if(ui->sourceRb->isChecked())
    {
        modelType = SourceModel;
        exportNumbersBySegment(sourceModel);
    }
    else
    {
        modelType = DestModel;
        exportNumbersBySegment(destModel);
    }

}
void FormCube::on_exportByTimesPB_clicked()
{
    if(!checkThreadFinished())
        return ;
    if(ui->sourceRb->isChecked())
    {
        modelType = SourceModel;
        exportNumbersByTimes(sourceModel);
    }
    else
    {
        modelType = DestModel;
        exportNumbersByTimes(destModel);
    }
}
void FormCube::on_exportByRegionPB_clicked()
{
    if(!checkThreadFinished())
        return ;
    if(ui->sourceRb->isChecked())
    {
        modelType = SourceModel;
        exportNumbersByCity(sourceModel);
    }
    else
    {
        modelType = DestModel;
        exportNumbersByCity(destModel);
    }
}

void FormCube::on_copyPB_clicked()
{
    if(!checkThreadFinished())
        return ;
    copy();

}

void FormCube::on_sortPB_clicked()
{
    if(!checkThreadFinished())
        return ;
    modelType = SourceModel;
    processNumbers(sourceModel,NumberSort);
}

void FormCube::on_noorderPB_clicked()
{
    if(!checkThreadFinished())
        return ;
    modelType = SourceModel;
    processNumbers(sourceModel,NumberOutOfOrder);
}
void FormCube::on_removeDuplicatesPB_clicked()
{
    if(!checkThreadFinished())
        return ;
    modelType = SourceModel;
    processNumbers(sourceModel,NumberRemoveDuplicate);
}
void FormCube::on_removeNotPhonePB_clicked()
{
    if(!checkThreadFinished())
        return ;
    modelType = SourceModel;
    processNumbers(sourceModel,NumberRemoveNotPhone);
}

void FormCube::on_blacklistPB_clicked()
{
    if(!checkThreadFinished())
        return ;
    modelType = SourceModel;
    processNumbers(sourceModel,NumberRemoveBlackList);
}
void FormCube::on_sort2PB_clicked()
{
    if(!checkThreadFinished())
        return ;
    modelType = DestModel;
    processNumbers(destModel,NumberSort);
}
void FormCube::on_dissort2PB_clicked()
{
    if(!checkThreadFinished())
        return ;
    modelType = DestModel;
    processNumbers(destModel,NumberOutOfOrder);
}
void FormCube::on_removeDuplicate2PB_clicked()
{
    if(!checkThreadFinished())
        return ;
    modelType = DestModel;
    processNumbers(destModel,NumberRemoveDuplicate);
}
void FormCube::on_blacklist2PB_clicked()
{
    if(!checkThreadFinished())
        return ;
    modelType = DestModel;
    processNumbers(destModel,NumberRemoveBlackList);
}
void FormCube::on_comparePB_clicked()
{

    DialogFileCompare *dialog=new DialogFileCompare(this);
    dialog->setAvailableCount((sourceModel->getCount()+destModel->getCount())/10000);
    QObject::connect(dialog,SIGNAL(joinSource(QStringList)),this,SLOT(onJoinSource(QStringList)));
    dialog->setModal(true);
    dialog->exec();
    delete dialog;
}
void FormCube::buildFromFile(NumberBuildType buildType)
{
    QStringList fileNames = getOpenFileNames();
    if (fileNames.isEmpty())
    {
        threadsFinished = true;
        return ;
    }
    if(!checkCurrentSystemAvailable(fileNames))
        return ;
    execTime.start();
    this->ui->lblProgress->setVisible(true);

    fileImportProxy = new ImportProxy(sourceModel);
    fileImportProxy->setFetchList(fileNames);
    fileImportProxy->setBuildType(buildType);
    QObject::connect(fileImportProxy,SIGNAL(numberBuilt(NumberListModel*)),this,SLOT(onNumberBuilt(NumberListModel*)));
    QObject::connect(fileImportProxy,SIGNAL(progressMaxUpdated(int)),this,SLOT(onProgressMaxUpdated(int)));
    QObject::connect(fileImportProxy,SIGNAL(progressUpdated(int)),this,SLOT(onProgressUpdated(int)));
    fileImportProxy->start();
}
void FormCube::buildFromExtract()
{
    DialogSetExtractMethod *dialog=new DialogSetExtractMethod(this);
    dialog->setModal(true);
    int dialogcode = dialog->exec();
    NumberBuildType build_type = dialog->getExtractMethod();
    delete dialog;
    if(dialogcode==QDialog::Rejected)
    {
        threadsFinished = true;
        return ;
    }
    if(build_type==NumberFromFileExtract)
        buildFromFile(NumberFromFileExtract);
    else
        buildFromPaste();
}
void FormCube::buildFromSegments(QStringList segments)
{
    if(!checkCurrentSystemAvailable(segments.size()))
        return ;
    execTime.start();
    this->ui->lblProgress->setVisible(true);

    QString reg = "\\d{4}";
    QMultiMap<int,QString> map;
    map.insert(0,reg);

    numberCreate = new NumberCreate(sourceModel);
    numberCreate->setFilters(map);
    numberCreate->setSegments(segments);
    QObject::connect(numberCreate,SIGNAL(progressMaxUpdated(int)),this,SLOT(onProgressMaxUpdated(int)));
    QObject::connect(numberCreate,SIGNAL(progressUpdated(int)),this,SLOT(onProgressUpdated(int)));
    QObject::connect(numberCreate,SIGNAL(numberCreated(NumberListModel*)),this,SLOT(onNumberBuilt(NumberListModel*)));
    numberCreate->start();
}
void FormCube::buildFromInputSegment()
{
    DialogInputNumSeg *dialog=new DialogInputNumSeg(this);
    dialog->setModal(true);
    int dialogcode = dialog->exec();
    QString segment = dialog->getNumSeg();
    delete dialog;
    if(dialogcode==QDialog::Rejected)
    {
        threadsFinished = true;
        return ;
    }
    QStringList segments;
    segments<<segment;
    buildFromSegments(segments);
}
void FormCube::buildFromImportSegment()
{
    QStringList segments;
    DialogSelectSegment * dialog = new DialogSelectSegment(this);
    dialog->setModal(true);
    int dialogcode = dialog->exec();
    segments = dialog->getSelectedSegment();
    if(dialogcode==QDialog::Rejected)
    {
        threadsFinished = true;
        return ;
    }
    if(!segments.isEmpty())
    {
        buildFromSegments(segments);
    }
    else
    {
        threadsFinished = true;
    }
}
void FormCube::buildFromPaste()
{
    QClipboard *board = QApplication::clipboard();
    QString content = board->text();
    if(content.isEmpty())
    {
        QMessageBox::critical(this,"提示","剪贴板不可用!",QMessageBox::Ok);
        threadsFinished = true;
        return ;
    }
    if(!checkCurrentSystemAvailable(content))
        return ;
    execTime.start();
    QStringList contents;
    this->ui->lblProgress->setVisible(true);
    contents.append(content);
    fileImportProxy  = new ImportProxy(sourceModel);
    fileImportProxy->setFetchList(contents);
    fileImportProxy->setBuildType(NumberFromContent);
    QObject::connect(fileImportProxy,SIGNAL(numberBuilt(NumberListModel*)),this,SLOT(onNumberBuilt(NumberListModel*)));
    QObject::connect(fileImportProxy,SIGNAL(progressMaxUpdated(int)),this,SLOT(onProgressMaxUpdated(int)));
    QObject::connect(fileImportProxy,SIGNAL(progressUpdated(int)),this,SLOT(onProgressUpdated(int)));
    fileImportProxy->start();
}

QStringList FormCube::extractSegmentFromTxtFile(QString fileName)
{
    QStringList segs;
    QFile file(fileName);
    if(!file.open(QIODevice::ReadOnly))
    {
        return segs;
    }
    QTextStream in(&file);
    while(!in.atEnd())
    {
        QString line = in.readLine();
        if(NumberReg::getSegmentReg().exactMatch(line))
            segs<<line;
    }
    file.close();
    return segs;
}

void FormCube::onNumberProcessed(NumberListModel *model)
{
    if(outOrder)
    {
        outOrder->wait();
        delete outOrder;
        outOrder = 0;
    }
    if(numberProcess)
    {
        numberProcess->wait();
        delete numberProcess;
        numberProcess = 0;
    }
    if(modelType == SourceModel)
    {
        delete sourceModel;
        sourceModel = model;
        //this->ui->sourceListView->setModel(sourceModel);
        ddListView->setModel(sourceModel);
    }
    if(modelType == DestModel)
    {
        delete destModel;
        destModel = model;
        this->ui->destListView->setModel(destModel);
    }
    displayStatistics();
    threadsFinished = true;
    this->ui->progressBar->setValue(0);
    this->ui->lblProgress->setVisible(false);
}
void FormCube::onNumberBuilt(NumberListModel *model)
{
    if(fileImportProxy)
    {
        fileImportProxy->wait();
        delete fileImportProxy;
        fileImportProxy = 0;
    }
    if(numberCreate)
    {
        numberCreate->wait();
        delete numberCreate;
        numberCreate = 0;
    }
    delete sourceModel;
    sourceModel = model;
    //this->ui->sourceListView->setModel(sourceModel);
    ddListView->setModel(sourceModel);
    displayStatistics();
    this->ui->progressBar->setValue(0);
    this->ui->lblProgress->setVisible(false);
    threadsFinished = true;
}

void FormCube::onBlackListNumberBuilt(NumberListModel *model)
{
    if(fileImportProxy)
    {
        fileImportProxy->wait();
        delete fileImportProxy;
        fileImportProxy = 0;
    }
    if(blackListModel)
    {
        blackListModel->clear();
        delete blackListModel;
    }
    blackListModel = model;
    if(modelType == SourceModel)
    {
       numberProcess = new NumberProcessorProxy(sourceModel);
    }
    else
    {
        numberProcess = new NumberProcessorProxy(destModel);
    }

    QObject::connect(numberProcess,SIGNAL(progressMaxUpdated(int)),this,SLOT(onProgressMaxUpdated(int)));
    QObject::connect(numberProcess,SIGNAL(progressUpdated(int)),this,SLOT(onProgressUpdated(int)));
    QObject::connect(numberProcess,SIGNAL(numberProcessed(NumberListModel*)),this,SLOT(onNumberProcessed(NumberListModel*)));
    numberProcess->setProcessType(NumberRemoveBlackList);
    numberProcess->setBlackList(blackListModel);
    numberProcess->start();
}
void FormCube::onNumberMoved(NumberListModel *fromModel, NumberListModel *toModel)
{
    if(numberMove)
    {
        numberMove->wait();
        delete numberMove;
        numberMove = 0;
    }
    //this->cacheView->setVisible(false);
    //this->ui->destListView->setVisible(true);
    if(this->moveDirection==UpDirection)
    {
        delete sourceModel;
        delete destModel;
        sourceModel = toModel;
        destModel = fromModel;
    }
    if(this->moveDirection==DownDirection)
    {
        delete sourceModel;
        delete destModel;
        destModel = toModel;
        sourceModel = fromModel;
    }
    //this->ui->sourceListView->setModel(sourceModel);
    ddListView->setModel(sourceModel);
    this->ui->destListView->setModel(destModel);
    displayStatistics();
    threadsFinished = true;
    this->ui->progressBar->setValue(0);
    this->ui->lblProgress->setVisible(false);
}
void FormCube::processNumbers(NumberListModel *model,NumberProcessType processType)
{
    if(!checkModel(model))
        return ;
    if(processType == NumberRemoveBlackList)
    {
        QString fileName;
        QStringList fileNames;
        fileName = getOpenFileName();
        if (fileName.isEmpty())
        {
            threadsFinished = true;
            return ;
        }
        fileNames<<fileName;
        if(!checkCurrentSystemAvailable(fileNames))
            return ;
        execTime.start();
        this->ui->lblProgress->setVisible(true);
        blackListModel = new NumberListModel();
        fileImportProxy = new ImportProxy(blackListModel);
        fileImportProxy->setFetchList(fileNames);
        fileImportProxy->setBuildType(NumberFromFileImport);
        QObject::connect(fileImportProxy,SIGNAL(numberBuilt(NumberListModel*)),this,SLOT(onBlackListNumberBuilt(NumberListModel*)));
        fileImportProxy->start();
    }
    else if(processType==NumberOutOfOrder)
    {
        execTime.start();
        this->ui->lblProgress->setVisible(true);
        outOrder = new NumberOutOrder(model);
        QObject::connect(outOrder,SIGNAL(numberProcessed(NumberListModel*)),this,SLOT(onNumberProcessed(NumberListModel*)));
        QObject::connect(outOrder,SIGNAL(progressMaxUpdated(int)),this,SLOT(onProgressMaxUpdated(int)));
        QObject::connect(outOrder,SIGNAL(progressUpdated(int)),this,SLOT(onProgressUpdated(int)));
        outOrder->start();
    }
    else
    {
        execTime.start();
        this->ui->lblProgress->setVisible(true);
        numberProcess = new NumberProcessorProxy(model);
        QObject::connect(numberProcess,SIGNAL(progressMaxUpdated(int)),this,SLOT(onProgressMaxUpdated(int)));
        QObject::connect(numberProcess,SIGNAL(progressUpdated(int)),this,SLOT(onProgressUpdated(int)));
        QObject::connect(numberProcess,SIGNAL(numberProcessed(NumberListModel*)),this,SLOT(onNumberProcessed(NumberListModel*)));
        numberProcess->setProcessType(processType);
        numberProcess->start();
    }
}



void FormCube:: moveNumberByCombo(NumberListModel *fromModel,NumberListModel *toModel,NumberMoveDirection moveDirection)
{
    if(!checkModel(fromModel))
        return ;

    this->moveDirection = moveDirection;
    DialogSetComboFilter *dialog=new DialogSetComboFilter(this);
    dialog->setModal(true);
    int dialogcode = dialog->exec();
    QStringList list = dialog->getFiltersByCombo();
    delete dialog;
    if(dialogcode==QDialog::Rejected)
    {
        threadsFinished = true;
        return ;
    }
    QList<QRegExp> regExpList;
    for (int i =0;i<list.size();i++)
    {
        regExpList.append(QRegExp(list.at(i)));
    }
    filterNumberByRegExp(fromModel,toModel,regExpList);
}
void FormCube::moveNumberByType(NumberListModel *fromModel,NumberListModel *toModel,NumberMoveDirection moveDirection)
{
    if(!checkModel(fromModel))
        return ;
    this->moveDirection = moveDirection;
    DialogSetTypeFilter *dialog=new DialogSetTypeFilter(this);
    dialog->setModal(true);
    int dialogcode = dialog->exec();
    QString str = dialog->getFilterByType();
    delete dialog;
    if(dialogcode==QDialog::Rejected)
    {
        threadsFinished = true;
        return ;
    }
    QList<QRegExp> regExpList;
    if(str=="CMCC")
    {
        regExpList.append(NumberReg::getCMCCReg());
        filterNumberByRegExp(fromModel,toModel,regExpList);
    }
    else if(str=="CUTC")
    {
        regExpList.append(NumberReg::getCUTCReg());
        filterNumberByRegExp(fromModel,toModel,regExpList);
    }
    else if(str=="CTCC")
    {
        regExpList.append(NumberReg::getCTCCReg());
        filterNumberByRegExp(fromModel,toModel,regExpList);
    }
    else if(str.length()==23)
    {
        QStringList list = str.split("-");
        QString start ,end ;
        start = list.first();
        end = list.last();
        qDebug() << start;
        filterNumberByRange(fromModel,toModel,start,end);
    }
}
void FormCube::moveNumberByValue(NumberListModel *fromModel,NumberListModel *toModel,NumberMoveDirection moveDirection)
{
    if(!checkModel(fromModel))
        return ;
    this->moveDirection = moveDirection;
    DialogSetValueFilter *dialog=new DialogSetValueFilter(this);
    dialog->setModal(true);
    int dialogcode = dialog->exec();
    QRegExp regexp(dialog->getFilterByValue());
    QList<QRegExp> regExpList;
    regExpList.append(regexp);
    delete dialog;
    if(dialogcode==QDialog::Rejected)
    {
        threadsFinished = true;
        return ;
    }
    filterNumberByRegExp(fromModel,toModel,regExpList);
}
void FormCube::moveNumerByAll(NumberListModel *fromModel,NumberListModel *toModel,NumberMoveDirection moveDirection)
{
    if(!checkModel(fromModel))
        return ;
    execTime.start();
    this->moveDirection = moveDirection;
    this->ui->lblProgress->setVisible(true);
    numberMove = new NumberMoveProxy(fromModel,toModel);
    QObject::connect(numberMove,SIGNAL(progressMaxUpdated(int)),this,SLOT(onProgressMaxUpdated(int)));
    QObject::connect(numberMove,SIGNAL(progressUpdated(int)),this,SLOT(onProgressUpdated(int)));
    QObject::connect(numberMove,SIGNAL(numberMoved(NumberListModel*,NumberListModel*)),
                     this,SLOT(onNumberMoved(NumberListModel*,NumberListModel*)));
    numberMove->setMoveType(MoveByAll);
    numberMove->start();
}
void FormCube::filterNumberByRegExp(NumberListModel *fromModel,NumberListModel *toModel,QList<QRegExp> regExpList)
{
    execTime.start();
    this->ui->lblProgress->setVisible(true);
    numberMove = new NumberMoveProxy(fromModel,toModel);
    QObject::connect(numberMove,SIGNAL(progressMaxUpdated(int)),this,SLOT(onProgressMaxUpdated(int)));
    QObject::connect(numberMove,SIGNAL(progressUpdated(int)),this,SLOT(onProgressUpdated(int)));
    QObject::connect(numberMove,SIGNAL(numberMoved(NumberListModel*,NumberListModel*)),
                     this,SLOT(onNumberMoved(NumberListModel*,NumberListModel*)));
    numberMove->setMoveType(MoveByRegex);
    numberMove->setRegexpList(regExpList);
    numberMove->start();
}
void FormCube::filterNumberByRange(NumberListModel *fromModel,NumberListModel *toModel,QString range1,QString range2)
{
    execTime.start();
    this->ui->lblProgress->setVisible(true);
    numberMove = new NumberMoveProxy(fromModel,toModel);
    QObject::connect(numberMove,SIGNAL(progressMaxUpdated(int)),this,SLOT(onProgressMaxUpdated(int)));
    QObject::connect(numberMove,SIGNAL(progressUpdated(int)),this,SLOT(onProgressUpdated(int)));
    QObject::connect(numberMove,SIGNAL(numberMoved(NumberListModel*,NumberListModel*)),
                     this,SLOT(onNumberMoved(NumberListModel*,NumberListModel*)));
    numberMove->setMoveType(MoveByRange);
    numberMove->setRange(range1,range2);
    numberMove->start();
}

void FormCube::exportNumbersByALL(NumberListModel *model)
{
    if(!checkModel(model))
        return ;
    QString prefix = getSaveFileNamePrefix();
    if (prefix.isEmpty())
    {
        threadsFinished = true;
        return ;
    }
    execTime.start();
    this->ui->lblProgress->setVisible(true);
    numberExport= new NumberExport(model,prefix,ExportByAll);
    QObject::connect(numberExport,SIGNAL(progressMaxUpdated(int)),SLOT(onProgressMaxUpdated(int)));
    QObject::connect(numberExport,SIGNAL(progressUpdated(int)),this,SLOT(onProgressUpdated(int)));
    QObject::connect(numberExport,SIGNAL(exportFinished()),this,SLOT(onExportFinished()));
    numberExport->start();
}
void FormCube::exportNumbersByCorp(NumberListModel *model)
{
    if(!checkModel(model))
        return ;

    QString prefix = getSaveFileNamePrefix();
    if (prefix.isEmpty())
    {
        threadsFinished = true;
        return ;
    }
    execTime.start();
    this->ui->lblProgress->setVisible(true);
    numberExport= new NumberExport(model,prefix,ExportByCorp);
    QObject::connect(numberExport,SIGNAL(progressMaxUpdated(int)),SLOT(onProgressMaxUpdated(int)));
    QObject::connect(numberExport,SIGNAL(progressUpdated(int)),this,SLOT(onProgressUpdated(int)));
    QObject::connect(numberExport,SIGNAL(exportFinished()),this,SLOT(onExportFinished()));
    numberExport->start();
}
void FormCube::exportNumbersBySegment(NumberListModel *model)
{
    if(!checkModel(model))
        return ;
    DialogSetSegment *dialog=new DialogSetSegment(this);
    dialog->setModal(true);
    int dialogcode = dialog->exec();
    int length = dialog->getSegmentLenth();
    delete dialog;
    if(dialogcode==QDialog::Rejected)
    {
        threadsFinished = true;
        return ;
    }
    QString prefix = getSaveFileNamePrefix();
    if (prefix.isEmpty())
    {
        threadsFinished = true;
        return ;
    }
    execTime.start();
    this->ui->lblProgress->setVisible(true);
    numberExport= new NumberExport(model,prefix,ExportBySegment);
    QObject::connect(numberExport,SIGNAL(progressMaxUpdated(int)),SLOT(onProgressMaxUpdated(int)));
    QObject::connect(numberExport,SIGNAL(progressUpdated(int)),this,SLOT(onProgressUpdated(int)));
    QObject::connect(numberExport,SIGNAL(exportFinished()),this,SLOT(onExportFinished()));
    numberExport->setSegment(length);
    numberExport->start();
}
void FormCube::exportNumbersByBatch(NumberListModel *model)
{
    if(!checkModel(model))
        return ;
    DialogExportBatchSet *dialog=new DialogExportBatchSet(this);
    dialog->setModal(true);
    int dialogcode = dialog->exec();
    int batch = dialog->getBatch();
    bool isAll = dialog->getIsAll();
    delete dialog;
    if(dialogcode==QDialog::Rejected)
    {
        threadsFinished = true;
        return ;
    }

    QString prefix = getSaveFileNamePrefix();
    if (prefix.isEmpty())
    {
        threadsFinished = true;
        return ;
    }
    execTime.start();
    this->ui->lblProgress->setVisible(true);
    numberExport= new NumberExport(model,prefix,ExportByBatch);
    numberExport->setGroupSate(isAll);
    numberExport->setBatchSize(batch);
    QObject::connect(numberExport,SIGNAL(progressMaxUpdated(int)),SLOT(onProgressMaxUpdated(int)));
    QObject::connect(numberExport,SIGNAL(progressUpdated(int)),this,SLOT(onProgressUpdated(int)));
    QObject::connect(numberExport,SIGNAL(exportFinished()),this,SLOT(onExportFinished()));
    numberExport->start();
}
void FormCube::exportNumbersByTimes(NumberListModel *model)
{
    if(!checkModel(model))
        return ;
    QString prefix = getSaveFileNamePrefix();
    if (prefix.isEmpty())
    {
        threadsFinished = true;
        return ;
    }
    execTime.start();
    this->ui->lblProgress->setVisible(true);
    numberExport= new NumberExport(model,prefix,ExportByDuplicate);
    QObject::connect(numberExport,SIGNAL(progressMaxUpdated(int)),SLOT(onProgressMaxUpdated(int)));
    QObject::connect(numberExport,SIGNAL(progressUpdated(int)),this,SLOT(onProgressUpdated(int)));
    QObject::connect(numberExport,SIGNAL(exportFinished()),this,SLOT(onExportFinished()));
    numberExport->start();
}

void FormCube::exportNumbersByCity(NumberListModel *model)
{
    if(!checkModel(model))
        return ;
    DialogSetExportRegionType *dialog=new DialogSetExportRegionType(this);
    dialog->setModal(true);
    int dialogcode = dialog->exec();
    bool iscity = dialog->getExportRegionType();
    delete dialog;
    if(dialogcode==QDialog::Rejected)
    {
        threadsFinished = true;
        return ;
    }
    QString prefix = getSaveFileNamePrefix();
    if (prefix.isEmpty())
    {
        threadsFinished = true;
        return ;
    }
    execTime.start();
    this->ui->lblProgress->setVisible(true);
    numberExport= new NumberExport(model,prefix,ExportByRegion);
    numberExport->setCityOrProvince(iscity);
    QObject::connect(numberExport,SIGNAL(progressMaxUpdated(int)),SLOT(onProgressMaxUpdated(int)));
    QObject::connect(numberExport,SIGNAL(progressUpdated(int)),this,SLOT(onProgressUpdated(int)));
    QObject::connect(numberExport,SIGNAL(exportFinished()),this,SLOT(onExportFinished()));
    numberExport->start();
}

void FormCube::onExportFinished()
{
    if(numberExport)
    {
        numberExport->abort();
        numberExport->wait();
        delete numberExport;
        numberExport = 0;
    }
    if(modelType==SourceModel)
        sourceModel->clear();
    if(modelType==DestModel)
        destModel->clear();
    displayStatistics();
    this->ui->lblProgress->setVisible(false);
    this->ui->progressBar->setValue(0);
    QMessageBox::information(this,"结果","号码导出完成！",QMessageBox::Ok);
    threadsFinished = true;
}

QString FormCube::getSaveFileNamePrefix()
{
    QFileDialog::Options options;
    options |= QFileDialog::DontConfirmOverwrite;
    QString selectedFilter;
    QString exportDir = SNCDataBase::getExportDir();
    if(exportDir.isEmpty())
    {
        exportDir = QDesktopServices::storageLocation(QDesktopServices::DesktopLocation);
    }
    QString fileName = QFileDialog::getSaveFileName(this,
                                "导出文件",exportDir,
                                tr("Text Files (*.txt)"),
                                &selectedFilter,
                                options);
    if(!fileName.isEmpty())
    {
        QFileInfo fileInfo(fileName);
        exportDir = fileInfo.absolutePath();
        SNCDataBase::updateExportDir(exportDir);
        return fileInfo.absolutePath()+"/"+ fileInfo.completeBaseName();
    }
    else
        return fileName;
}
QString FormCube::getOpenFileName()
{
    QFileDialog::Options options;
    //options |= QFileDialog::DontUseNativeDialog;
    QString selectedFilter;
    QString importDir = SNCDataBase::getImportDir();
    if(importDir.isEmpty())
    {
        importDir = QDesktopServices::storageLocation(QDesktopServices::DesktopLocation);
    }
    QString fileName = QFileDialog::getOpenFileName(this,
                                "导入文件",importDir,
                                tr("Text Files (*.txt)"),
                                &selectedFilter,
                                options);
    if(!fileName.isEmpty())
    {
        QFileInfo fileInfo(fileName);
        importDir = fileInfo.absolutePath();
        SNCDataBase::updateImportDir(importDir);
    }
    return fileName;
}
QStringList FormCube::getOpenFileNames()
{
    QFileDialog::Options options;
    //options |= QFileDialog::DontUseNativeDialog;
    QString selectedFilter;
    QString importDir = SNCDataBase::getImportDir();
    if(importDir.isEmpty())
    {
        importDir = QDesktopServices::storageLocation(QDesktopServices::DesktopLocation);
    }
    QStringList fileNames = QFileDialog::getOpenFileNames(this,"导入文件",importDir,
                                tr("Text Files (*.txt)"),&selectedFilter,options);
    if(!fileNames.isEmpty())
    {
        QFileInfo fileInfo(fileNames.at(fileNames.size()-1));
        importDir = fileInfo.absolutePath();
        SNCDataBase::updateImportDir(importDir);
    }
    return fileNames;
}
bool FormCube::checkThreadFinished()
{
    if(!threadsFinished)
    {
        QMessageBox::information(this,"提示","当前任务暂未结束，请等待当前任务结束后再执行下一操作",
                                 QMessageBox::Ok);
        return false;
    }
    threadsFinished = false;
    return true;
}

void FormCube::displayStatistics()
{
    //ui->sourcecounterLabel->setText("当前原始号码："+number2Thousandth(sourceModel->getCount())+"个");
    //ui->destcounterLabel->setText("当前目标号码："+number2Thousandth(destModel->getCount())+"个");
    ui->sourcecounterLabel->setText(QString::fromLocal8Bit(("当前原始号码："+number2Thousandth(sourceModel->getCount())+"个").toLocal8Bit()));
    ui->destcounterLabel->setText(QString::fromLocal8Bit(("当前目标号码："+number2Thousandth(destModel->getCount())+"个").toLocal8Bit()));

    if(destModel->getCount()<=0)
    {
        this->cacheViewDest->setVisible(true);
        ui->destListView->setVisible(false);
    }
    else
    {
        this->cacheViewDest->setVisible(false);
        ui->destListView->setVisible(true);
    }
    if(sourceModel->getCount()<=0)
    {
        this->cacheViewSource->setVisible(true);
        ddListView->setVisible(false);
    }
    else
    {
        this->cacheViewSource->setVisible(false);
        ddListView->setVisible(true);
    }
    qDebug()<<QDateTime::currentDateTime().toString("yyyy-MM-dd HH:mm:ss")\
           <<"Elapse Time"<<execTime.elapsed();
}
void FormCube::onProgressUpdated(int current)
{
    this->ui->progressBar->setValue(current);
}

void FormCube::onBlackListProgressMaxUpdated(int max)
{
    this->ui->progressBar->setMaximum(max*2);
    this->ui->progressBar->setMinimum(0);
    this->ui->progressBar->setValue(0);
}

void FormCube::onBlackProgressUpdated(int current)
{
    this->ui->progressBar->setValue(current);
}
void FormCube::onProgressMaxUpdated(int max)
{
    this->ui->progressBar->setMaximum(max);
    this->ui->progressBar->setMinimum(0);
    this->ui->progressBar->setValue(0);
}


void FormCube::clearNumberListModel(NumberListModel *model)
{
    model->clear();
    displayStatistics();
    threadsFinished = true;
}

void FormCube::copy()
{
    if(sourceModel->getCount()>3000000)
    {
        QMessageBox::critical(this,"提示","您要复制的号码超出了系统处理能力！",QMessageBox::Ok);
        threadsFinished = true;
        return;
    }
    else if(sourceModel->getCount()==0)
    {
        QMessageBox::critical(this,"提示","要复制的号码不存在！",QMessageBox::Ok);
        threadsFinished = true;
        return;
    }
    this->ui->lblProgress->setVisible(true);
    numberCopy = new NumberCopy(sourceModel);
    QObject::connect(numberCopy,SIGNAL(numberCopyed(QString)),this,SLOT(onNumberCopy(QString)));
    QObject::connect(numberCopy,SIGNAL(progressMaxUpdated(int)),this,SLOT(onProgressMaxUpdated(int)));
    QObject::connect(numberCopy,SIGNAL(progressUpdated(int)),this,SLOT(onProgressUpdated(int)));
    numberCopy->start();

}

void FormCube::copy2()
{
    if(destModel->getCount()>3000000)
    {
        QMessageBox::critical(this,"提示","您要复制的号码超出了系统处理能力！",QMessageBox::Ok);
        threadsFinished = true;
        return;
    }
    else if(destModel->getCount()==0)
    {
        QMessageBox::critical(this,"提示","要复制的号码不存在！",QMessageBox::Ok);
        threadsFinished = true;
        return;
    }
    this->ui->lblProgress->setVisible(true);
    numberCopy = new NumberCopy(destModel);
    QObject::connect(numberCopy,SIGNAL(numberCopyed(QString)),this,SLOT(onNumberCopy(QString)));
    QObject::connect(numberCopy,SIGNAL(progressMaxUpdated(int)),this,SLOT(onProgressMaxUpdated(int)));
    QObject::connect(numberCopy,SIGNAL(progressUpdated(int)),this,SLOT(onProgressUpdated(int)));
    numberCopy->start();

}
void FormCube::onNumberCopy(QString content)
{
    if(numberCopy)
    {
        numberCopy->wait();
        delete numberCopy;
        numberCopy = 0;
    }
    this->ui->lblProgress->setVisible(false);
    this->ui->progressBar->setValue(0);
    QClipboard *board = QApplication::clipboard();
    board->setText(content);
    QMessageBox::information(this,"结果","复制完成！",QMessageBox::Ok);
    threadsFinished = true;
}
void FormCube::onAdUpdated(QString adText,QString adUrl)
{
    ui->adLabel->setText("<a href="+adUrl+">"+adText+"</a>");
}
void FormCube::onLinkActivated(QString url)
{
    QDesktopServices::openUrl(QUrl(url));
}
void FormCube::onLinkClicked(QUrl url)
{
    QDesktopServices::openUrl(url);
}
void FormCube::initAD()
{
    page_ads = SNCDataBase::getLocalPageAds();
    cacheViewSource = new CacheWebView(this);
    ui->horizontalLayoutSource->addWidget(cacheViewSource);
    QString up_url = "";
    QString bottom_url = "";
    if(page_ads.count()>0)
    {
        up_url = page_ads.value("ad_app2_index_up");
        bottom_url = page_ads.value("ad_app2_index_bottom");
    }
    cacheViewSource->setPageUrl(up_url+"?s=s&ver="+SNCDataBase::getAppVersion(),QCoreApplication::applicationDirPath()+"/cache");
    cacheViewDest = new CacheWebView(this);
    ui->verticalLayoutWebview->addWidget(cacheViewDest);
    cacheViewDest->setPageUrl(bottom_url+"?ver="+SNCDataBase::getAppVersion(),QCoreApplication::applicationDirPath()+"/cache");
    ad = new Advertisement();
    ui->destListView->setVisible(false);
    QObject::connect(ad,SIGNAL(adUpdated(QString,QString)),SLOT(onAdUpdated(QString,QString)));
    QObject::connect(ui->adLabel,SIGNAL(linkActivated(QString)),this,SLOT(onLinkActivated(QString)));
    //ad->start();
    ui->adLabel->setVisible(false);
}
void FormCube::initListView()
{
    setAcceptDrops(true);
    ui->extractPB->setVisible(false);
    threadsFinished = true;
    blackListModel = 0;
    sourceModel = new NumberListModel(this);
    destModel = new NumberListModel(this);
    //ui->sourceListView->setModel(sourceModel);  //MVC VIEW
    ui->destListView->setModel(destModel);      //MVC VIEW
    //this->setWindowState(Qt::WindowMaximized);
    this->ui->lblProgress->setVisible(false);
    movie = new QMovie(":/working.gif");
    this->ui->lblProgress->setMovie(movie);
    movie->start();

    //mod by wzx
    //ui->groupBox_2->setMinimumHeight(291);
    //ui->groupBox_2->setMaximumHeight(291);
    //ui->groupBox->setMinimumHeight(206);
    //ui->groupBox->setMaximumHeight(206);

    ddListView = new DragDropListView(this);
    //ddListView->setMaximumHeight(ui->sourceListView->maximumHeight());
    //ddListView->setMinimumHeight(ui->sourceListView->minimumHeight());
    ddListView->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Fixed);
    ddListView->setVisible(false);
    connect(ddListView,SIGNAL(filesDragDropped(QStringList)),this,SLOT(onFileDnD(QStringList)));
    ui->horizontalLayoutSource->addWidget(ddListView);
    ui->sourceListView->setVisible(false);

}

void FormCube::initButton()
{
    for(int i=0;i<8;i++)
    {

        QPushButton *button = new QPushButton();
        buttons.append(button);
        if(i%2==0)
            button->setText(QString::fromLocal8Bit("↑"));
        else
            button->setText(QString::fromLocal8Bit("↓"));
        button->setSizePolicy(QSizePolicy::Fixed,QSizePolicy::Fixed);
        button->setFixedWidth(28);
        button->setFixedHeight(23);
        if(i==0||i==1)
            ui->horizontalLayout11->addWidget(button);
        if(i==2||i==3)
            ui->horizontalLayout22->addWidget(button);
        if(i==4||i==5)
            ui->horizontalLayout33->addWidget(button);
        if(i==6||i==7)
            ui->horizontalLayout44->addWidget(button);

    }
    connect(buttons[0],SIGNAL(clicked()),this,SLOT(slot_upbyvaluePB_clicked()));
    connect(buttons[1],SIGNAL(clicked()),this,SLOT(slot_downbyvaluePB_clicked()));
    connect(buttons[2],SIGNAL(clicked()),this,SLOT(slot_upbycomboPB_clicked()));
    connect(buttons[3],SIGNAL(clicked()),this,SLOT(slot_downbycomboPB_clicked()));
    connect(buttons[4],SIGNAL(clicked()),this,SLOT(slot_upbytypePB_clicked()));
    connect(buttons[5],SIGNAL(clicked()),this,SLOT(slot_downbytypePB_clicked()));
    connect(buttons[6],SIGNAL(clicked()),this,SLOT(slot_upbyallPB_clicked()));
    connect(buttons[7],SIGNAL(clicked()),this,SLOT(slot_downbyallPB_clicked()));

    ui->importSegmentsPB->setVisible(false);
    ui->inputnumsegPB->setVisible(false);
}
bool FormCube::checkModel(NumberListModel *model)
{
    if(model->getCount()==0)
    {
        QMessageBox::critical(this,"提示","没有可以操作的号码!",QMessageBox::Ok);
        threadsFinished = true;
        return false ;
    }
    else
        return true;
}
void FormCube::onJoinSource(QStringList fileNames)
{
    qDebug()<<fileNames;
    if (fileNames.isEmpty())
    {
        threadsFinished = true;
        return ;
    }
    if(!checkCurrentSystemAvailable(fileNames))
        return ;
    execTime.start();

    fileImportProxy = new ImportProxy(sourceModel);
    this->ui->lblProgress->setVisible(true);
    fileImportProxy->setFetchList(fileNames);
    fileImportProxy->setBuildType(NumberFromFileImport);
    QObject::connect(fileImportProxy,SIGNAL(numberBuilt(NumberListModel*)),this,SLOT(onNumberBuilt(NumberListModel*)));
    QObject::connect(fileImportProxy,SIGNAL(progressMaxUpdated(int)),this,SLOT(onProgressMaxUpdated(int)));
    QObject::connect(fileImportProxy,SIGNAL(progressUpdated(int)),this,SLOT(onProgressUpdated(int)));
    fileImportProxy->start();

}
bool FormCube::checkCurrentSystemAvailable(int count)
{
     if((sourceModel->getCount()+destModel->getCount())/10000+count>1500)
    {
        QMessageBox::critical(this,"提示","您要处理的号码已经超过系统处理能力!",QMessageBox::Ok);
        threadsFinished = true;
        return false;
    }
    else
    {
        return true;
    }
}
bool FormCube::checkCurrentSystemAvailable(QStringList files)
{
    int count=0;
    int all_files_size=0;
    for(int i=0;i<files.size();i++)
    {
        QFileInfo fileinfo(files.at(i));
        all_files_size+=fileinfo.size();
    }
    count =all_files_size/1024/127;
    if((sourceModel->getCount()+destModel->getCount())/10000+count>1500)
    {
        qDebug()<<(sourceModel->getCount()+destModel->getCount())/10000+count;
        QMessageBox::critical(this,"提示","您要处理的号码已经超过系统处理能力!",QMessageBox::Ok);
        threadsFinished = true;
        return false;
    }
    else
    {
        return true;
    }
}
bool FormCube::checkCurrentSystemAvailable(QString content)
{
    int count=0;
    count = count +content.size()/(127*1024);
    if((sourceModel->getCount()+destModel->getCount())/10000+count>1500)
    {
        QMessageBox::critical(this,"提示","您要处理的号码已经超过系统处理能力!",QMessageBox::Ok);
        threadsFinished = true;
        return false;
    }
    else
    {
        return true;
    }
}
void FormCube::resizeEvent(QResizeEvent *)
{
    this->ui->destListView->setFlow(QListView::TopToBottom)  ;
}

void FormCube::onFileDnD(QStringList files)
{
    QStringList fileNames = files;
    if (fileNames.isEmpty())
    {
        threadsFinished = true;
        return ;
    }
    if(!checkCurrentSystemAvailable(fileNames))
        return ;
    execTime.start();
    this->ui->lblProgress->setVisible(true);

    fileImportProxy = new ImportProxy(sourceModel);
    fileImportProxy->setFetchList(fileNames);
    fileImportProxy->setBuildType(NumberFromFileImport);
    QObject::connect(fileImportProxy,SIGNAL(numberBuilt(NumberListModel*)),this,SLOT(onNumberBuilt(NumberListModel*)));
    QObject::connect(fileImportProxy,SIGNAL(progressMaxUpdated(int)),this,SLOT(onProgressMaxUpdated(int)));
    QObject::connect(fileImportProxy,SIGNAL(progressUpdated(int)),this,SLOT(onProgressUpdated(int)));
    fileImportProxy->start();
}
QString FormCube::number2Thousandth(int n)
{
    QString str=QString::number(n);
    QString thousandth="";
    for(int i=0;i<str.length();i++)
    {
        if(str.length()-i>3 && (str.length()-i)%3 ==1 )
        {
            thousandth +=str[i]+",";
        }
        else
        {
            thousandth +=str[i];
        }
    }
    return thousandth;
}

void FormCube::on_pushButtonCopy2_clicked()
{
    if(!checkThreadFinished())
        return ;
    copy2();
}

void FormCube::onImportNumFileActionTriggered()
{
    if(!checkThreadFinished())
        return ;
    buildFromFile(NumberFromFileImport);
}

void FormCube::onImportSegFileActionTriggered()
{
    if(!checkThreadFinished())
        return ;
    QString fileName = getOpenFileName();
    if (fileName.isEmpty())
    {
        threadsFinished = true;
        return ;
    }
    QFileInfo fileinfo(fileName);
    if(fileinfo.size()/1024>50)
    {
        QMessageBox::critical(this,"提示","号段文件不能大于50K!",QMessageBox::Ok);
        threadsFinished = true;
        return ;
    }
    QStringList segments = extractSegmentFromTxtFile(fileName);
    if(!segments.isEmpty())
    {
        buildFromSegments(segments);
    }
    else
    {
        threadsFinished = true;
    }
}

void FormCube::onPreFileActionTriggered()
{
    DialogPreFile dialog;
    dialog.exec();
}

void FormCube::createPopmenu()
{
    menuPopup = new QMenu();
    menuPopup->addAction("导入号码文件...");
    menuPopup->addAction("导入号段文件...");
    menuPopup->addAction("输入号段...");
    menuPopup->addAction("导入号段...");
    //menuPopup->addAction("文件预处理...");
    ui->importFilePB->setMenu(menuPopup);
    connect(menuPopup->actions()[0],SIGNAL(triggered()),this,SLOT(onImportNumFileActionTriggered()));
    connect(menuPopup->actions()[1],SIGNAL(triggered()),this,SLOT(onImportSegFileActionTriggered()));
    connect(menuPopup->actions()[2],SIGNAL(triggered()),this,SLOT(on_inputnumsegPB_clicked()));
    connect(menuPopup->actions()[3],SIGNAL(triggered()),this,SLOT(on_importSegmentsPB_clicked()));
    //connect(menuPopup->actions()[2],SIGNAL(triggered()),this,SLOT(onPreFileActionTriggered()));
}

void FormCube::on_pushButtonHelpme_clicked()
{
    if(!checkThreadFinished())
        return ;

    DialogSelectSegment2 dialog;
    int dialogcode = dialog.exec();
    if(dialogcode==QDialog::Rejected)
    {
        threadsFinished = true;
        return ;
    }
    QList<QStringList> list=dialog.getSelectedSegmentsInfo();
    QStringList segments;
    for(int i=0;i<list.size();i++)
        segments<<list.at(i).at(1);
    if(!segments.isEmpty())
    {
        buildFromSegments(segments);
    }
    else
    {
        threadsFinished = true;
    }
}