#include "syschartdevelopermgt.h"
#include <QToolBar>
#include <QVBoxLayout>
#include <QTextCodec>
#include <QFileDialog>
#include <QListView>
#include <QDialogButtonBox>
#include <QFile>
#include <QTextStream>
#include <QDebug>
#include <topcore/topcore.h>
#include <topcore/topclasssqlthread.h>
#include <topcore/topenummanager.h>
#include <toputil/t.h>
#include <tdatabaseutil/tsqlconnectionpoolv2.h>
#include <tdatabaseutil/tsqlqueryv2.h>
#include <tdatabaseutil/tsqlselectorv2.h>
#include <tbaseutil/ttheme.h>
#include <tbaseutil/tdataparse.h>
#include <tbaseutil/tdataresponse.h>
#include <tbaseutil/tresource.h>
#include <tbaseutil/tenumlist.h>
#include <twidget/tmessagebox.h>
#include <twidget/tsplitter.h>
#include <twidget/ttableviewv2.h>
#include <twidget/ttableview.h>
#include <twidget/ttreemodel.h>
#include <twidget/tpagetool.h>
#include <twidget/tuiloader.h>
#include <twidget/tsearchentry.h>
#include <twidget/tdialog.h>
#include <twidget/tcodeedit.h>
#include <twidget/twidget.h>
#include <tchart/tchartwidget.h>
#include <tchart/tchartstore.h>
#include <tchart/tchartaxisnumeric.h>
#include "syschartdeveloper.h"
#include "../syschartnavigationmgt/syschartnavigation.h"

SysChartDeveloperMgt::SysChartDeveloperMgt(const QString &iModuleName, const QVariantMap &iUrlPars, QWidget *iParent)
    : TopClassAbs(iParent)
{
    this->setLicenseKey("sys_common");
    initModule(iModuleName,iUrlPars);
    initUi();
    initPreviewUi();
//    initSpecifiedClass();
    mLastDir = QStandardPaths::writableLocation(QStandardPaths::DesktopLocation);
    if (APP->getSetting(this->moduleName() + "/ImportExportDir").isValid()) {
        mLastDir = APP->getSetting(this->moduleName() + "/ImportExportDir").toString();
    }
    refresh();
    mDetail->refreshDatasource();
    mDetail->refreshGraph();
    refreshActionState();
}

SysChartDeveloperMgt::~SysChartDeveloperMgt()
{
    APP->saveSetting(this->moduleName() + "/ImportExportDir", QVariant::fromValue(mLastDir));
}

void SysChartDeveloperMgt::refresh(bool iResetPageBol)
{
    t::loading(this);
    TSqlSelectorV2 selector = getSqlSelector(iResetPageBol);
    QVariant data = doThreadWork(new TopClassSqlThread(this), TOPSQLTHREAD_SELECT_ARRAYMAP, QVariant::fromValue(selector));
    unloading();
    TDataResponse dataRes(data.toMap());
    if (dataRes.hasError()) {
        alertError(dataRes.errText(), "Error");
        return;
    }
    if (mPageTool != nullptr) {
        mPageTool->setRowCount(dataRes.dataCount(), true);
    }
    QVariantList dataList = dataRes.data().toList();
    TopClassHelper::formatTableData(this,&mTableConf,dataList);
    mTableView->loadData(dataList);
    mDetail->setUid("");
    alertOk(ttr("Data loaded"));
}

void SysChartDeveloperMgt::preview()
{
    if (this->selectedItems().size() == 0) return;
    QString selectId = this->selectedItems().first().toString();
    if (selectId == mLastChartNaviId) {
        if (mPreviewDlg->isMinimized()) {
            mPreviewDlg->showNormal();
        }
        mPreviewDlg->show();
        mPreviewDlg->activateWindow();
        return;
    } else {
        mLastChartNaviId = selectId;
    }
    mChartNaviWgt->setUid(selectId);
    mPreviewDlg->show();
}

QVariantList SysChartDeveloperMgt::selectedItems() const
{
    return mTableView->selectedPrimaryKeys();
}

QVariantList SysChartDeveloperMgt::selectedDataMaps() const
{
    return mTableView->selectedRowDataMaps();
}

QString SysChartDeveloperMgt::specifiedClass()
{
    return mSpecifiedClass;
}

void SysChartDeveloperMgt::setFileDir(const QString &iDir)
{
    mLastDir = iDir;
}

QString SysChartDeveloperMgt::lastFileDir()
{
    return mLastDir;
}

void SysChartDeveloperMgt::exportChart()
{
    QVariantList selectedKeys = mTableView->selectedPrimaryKeys();
    if (selectedKeys.size() == 0) {
        return;
    }
    MultiFileSelect *dlg =new MultiFileSelect(this);
    dlg->setOption(QFileDialog::DontUseNativeDialog, true);
    dlg->setFileMode(QFileDialog::Directory);
    dlg->setOption(QFileDialog::ShowDirsOnly);
    dlg->setLabelText(QFileDialog::Reject, this->ttr("Cancel"));
    QStringList selDirs;
    dlg->resize(900, 600);
    dlg->setDirectory(mLastDir);
    if(dlg->exec() == QDialog::Accepted) {
        selDirs = dlg->selectedFiles();
    }
    if (selDirs.size() == 0) {
        return;
    }
    QString selDir = selDirs.first();
    mLastDir = selDir;
    t::exporting(this);
    TSqlSelectorV2 selector;
    for (QVariant varKey: selectedKeys) {
        // 导航
        selector.clear();
        selector.setTable("pub_chart_navigation");
        QStringList fields;
        fields<<"class"<<"name"<<"parameter_list"<<"graph_layout"<<"remark";
        selector.setField(fields);
        selector.setFieldFormat("graph_layout", "json");
        selector.setWhere(mTableConf.primaryKey, varKey.toString());
        if (!mSpecifiedClass.isEmpty()) {
            selector.addWhere("class", mSpecifiedClass);
        }
        QVariant data = doThreadWork(new TopClassSqlThread(this), TOPSQLTHREAD_SELECT_MAP, QVariant::fromValue(selector));
        TDataResponse dataRes(data.toMap());
        if (dataRes.hasError()) {
            alertError(dataRes.errText(), "Error");
            unloading();
            return;
        }
        QVariantMap exportDataMap = dataRes.data().toMap();
        if (exportDataMap.isEmpty()) {
            continue;
        }
        QString chartName = exportDataMap.value("name").toString();
        if (chartName.isEmpty()) {
            continue;
        }
        if (!mSpecifiedClass.isEmpty()) {
            chartName = mSpecifiedClass + "." + chartName + ".chart.json";
        } else {
            chartName = chartName + ".chart.json";
        }
        QVariantList graphDataList;
        QVariantMap graphMap = exportDataMap.value("graph_layout").toMap();
        QVariantList childList = graphMap.value("child").toList();
        for (QVariant itemVar: childList) {
            QString graphName = itemVar.toMap().value("name").toString();
            if (graphName.isEmpty()) {
                continue;
            }
            QVariantMap graphDataMap;
            // 图表
            selector.clear();
            selector.setTable("pub_chart_graph");
            QStringList fields;
            fields<<"class"<<"name"<<"data"<<"chart_datasource_id"<<"dynamic"<<"remark"<<"parameter_remark";
            selector.setField(fields);
            selector.setWhere("name", graphName);
            if (!mSpecifiedClass.isEmpty()) {
                selector.addWhere("class", mSpecifiedClass);
            }
            QVariant data_g = doThreadWork(new TopClassSqlThread(this), TOPSQLTHREAD_SELECT_MAP, QVariant::fromValue(selector));
            TDataResponse dataResG(data_g.toMap());
            if (dataResG.hasError()) {
                alertError(dataResG.errText(), "Error");
                unloading();
                return;
            }
            QVariantMap graphMap = dataResG.data().toMap();
            if (graphMap.isEmpty()) {
                continue;
            }
            QString dataSrcId = graphMap.value("chart_datasource_id").toString();
            graphMap.remove("chart_datasource_id");
            graphDataMap.insert("graph", graphMap);
            //数据源
            if (!dataSrcId.isEmpty()) {
                selector.clear();
                selector.setTable("pub_chart_datasource");
                QStringList fields;
                fields<<"class"<<"name"<<"parameter"<<"data"<<"remark";
                selector.setField(fields);
                selector.setWhere("id", dataSrcId);
                if (!mSpecifiedClass.isEmpty()) {
                    selector.addWhere("class", mSpecifiedClass);
                }
                QVariant data_d = doThreadWork(new TopClassSqlThread(this), TOPSQLTHREAD_SELECT_MAP, QVariant::fromValue(selector));
                TDataResponse dataResD(data_d.toMap());
                if (dataResD.hasError()) {
                    alertError(dataResD.errText(), "Error");
                    unloading();
                    return;
                }
                QVariantMap dataSrcMap = dataResD.data().toMap();
                graphDataMap.insert("datasource", dataSrcMap);
            }
            graphDataList.append(graphDataMap);
        }
        exportDataMap.insert("graph_data", graphDataList);
        if (selDir.endsWith("/")) {
            selDir = selDir.remove(selDir.length() - 1, 1);
        }
        QString savePath = selDir + "/" + chartName;
        QString fileContent = TDataParse::variant2JsonStr(exportDataMap);
        QFile file(savePath);
        if (file.open(QIODevice::WriteOnly | QIODevice::Text)) {
            QTextStream stream(&file);
            stream.setCodec("UTF-8");
            stream<<fileContent;
            stream.flush();
            file.close();
        }
    }
    unloading();
    t::msgBoxExport(selDir + "/");
}

void SysChartDeveloperMgt::importChart()
{
    MultiFileSelect *dlg =new MultiFileSelect(this);
    dlg->setOption(QFileDialog::DontUseNativeDialog, true);

    //支持多选
    QListView *listView = dlg->findChild<QListView*>("listView");
    if (listView) {
        listView->setSelectionMode(QAbstractItemView::ExtendedSelection);
    }
    QTreeView *treeView = dlg->findChild<QTreeView*>();
    if (treeView) {
        treeView->setSelectionMode(QAbstractItemView::ExtendedSelection);
    }
    QDialogButtonBox *button = dlg->findChild<QDialogButtonBox *>("buttonBox");

    disconnect(button,SIGNAL(accepted()),dlg,SLOT(accept()));//使链接失效
    connect(button,SIGNAL(accepted()),dlg,SLOT(go()));//改成自己的槽
    dlg->setLabelText(QFileDialog::Reject, this->ttr("Cancel"));

    QStringList selFilePaths;
    dlg->resize(900, 600);
    dlg->setDirectory(mLastDir);
    if(dlg->exec()==QDialog::Accepted) {
        selFilePaths = dlg->selectedFiles();
    }
    if (selFilePaths.isEmpty()) {
        return;
    }
    QStringList allJsonFiles;
    QFileInfo lastPath(selFilePaths.last());
    mLastDir = lastPath.absolutePath();
    for (QString path: selFilePaths) {
        QFileInfo fileInfo(path);
        if (fileInfo.isDir()) {
            allJsonFiles.append(this->extractDir(path));
        } else if (path.endsWith(".chart.json", Qt::CaseInsensitive)) {
            allJsonFiles.append(path);
        }
    }
    if (allJsonFiles.isEmpty()) {
        t::msgBoxError(ttr("No valid files found!(.chart.json)"));
        return;
    }
    t::importing(this);
    QVariantList chartDataList;
    for (QString fileName: allJsonFiles) {
        QFile file(fileName);
        if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
            QString content = file.readAll();
            TError err;
            QVariantMap jsonData = TDataParse::jsonStr2Variant(content, &err).toMap();
            if (!err.isValid()) {
                QString name = jsonData.value("name").toString();
                if (name.isEmpty()) {
                    file.close();
                    continue;
                }
                chartDataList.append(jsonData);
            } else {
                qDebug()<<"parse file error: "<<err.text();
            }
            file.close();
        }
    }
    if (chartDataList.isEmpty()) {
        unloading();
        t::msgBoxError(ttr("No valid files found!"));
        return;
    }
    TSqlSelectorV2 selector;
    TSqlUpdaterV2 updater;
    for (QVariant var: chartDataList) {
        QVariantMap naviMap = var.toMap();
        QVariantList graphDataList = naviMap.value("graph_data").toList();
        naviMap.remove("graph_data");
        naviMap.insert("graph_layout", TDataParse::variant2JsonStr(naviMap.value("graph_layout")));
        QString naviName = naviMap.value("name").toString();
        selector.clear();
        selector.setTable("pub_chart_navigation");
        selector.setWhere("name", naviName);
        QVariant pcndata = doThreadWork(new TopClassSqlThread(this), TOPSQLTHREAD_SELECT_COUNT, QVariant::fromValue(selector));
        TDataResponse pcnDataRes(pcndata.toMap());
        if (pcnDataRes.hasError()) {
            unloading();
            alertError(ttr("Import failed!"), pcnDataRes.errText());
            return;
        }
        if (pcnDataRes.data().toInt() > 0) {
            unloading();
            alertError(ttr("Chart navigation: %1 already exists!").arg(naviName));
            refresh();
            mDetail->refreshGraph();
            mDetail->refreshDatasource();
            return;
        }
        TSqlInserterV2 sqlInserter;
        sqlInserter.setTable("pub_chart_navigation");
        sqlInserter.setData(naviMap);
        QVariant data = doThreadWork(new TopClassSqlThread(this), TOPSQLTHREAD_INSERT_ROW, QVariant::fromValue(sqlInserter));
        TDataResponse dataRes(data.toMap());
        if (dataRes.hasError()) {
            unloading();
            alertError(ttr("Import failed!"), dataRes.errText());
            return;
        }
        for (QVariant varGraph: graphDataList) {
            QVariantMap gDataMap = varGraph.toMap();
            QVariantMap graphMap = gDataMap.value("graph").toMap();
            QVariantMap dataSrcMap = gDataMap.value("datasource").toMap();
            QString dataSrcName = dataSrcMap.value("name").toString();
            if (!dataSrcName.isEmpty()) {
                selector.clear();
                selector.setTable("pub_chart_datasource");
                selector.setField("id");
                selector.setWhere("name", dataSrcName);
                QVariant pcddata = doThreadWork(new TopClassSqlThread(this), TOPSQLTHREAD_SELECT_VALUE, QVariant::fromValue(selector));
                TDataResponse pcdDataRes(pcddata.toMap());
                if (pcdDataRes.hasError()) {
                    unloading();
                    alertError(ttr("Import failed!"), pcdDataRes.errText());
                    return;
                }
                QString dataSrcId = pcdDataRes.data().toString();
                if (!dataSrcId.isEmpty()) {
                    graphMap.insert("chart_datasource_id", dataSrcId);
                    unloading();
                    QString ans = TMessageBox::warning(0, ttr("Chart datasource: %1 already exists!").arg(dataSrcName), "", "",
                                         QStringList() << ttr("Overwrite") + ":Ok:Ok:Warn" << ttr("Skip") + ":Skip:Cancel:Normal");
                    if (ans == "Ok") {
                        updater.clear();
                        updater.setTable("pub_chart_datasource");
                        updater.setData(dataSrcMap);
                        updater.setWhere("id", dataSrcId);
                        QVariant data_d = doThreadWork(new TopClassSqlThread(this), TOPSQLTHREAD_UPDATE_ROW, QVariant::fromValue(updater));
                        TDataResponse dataRes_d(data_d.toMap());
                        if (dataRes_d.hasError()) {
                            unloading();
                            alertError(ttr("Import failed!"), dataRes_d.errText());
                            return;
                        }
                    } else if (ans == "Skip") {
                    } else {
                        refresh();
                        mDetail->refreshGraph();
                        mDetail->refreshDatasource();
                        return;
                    }
                } else {
                    sqlInserter.clear();
                    sqlInserter.setTable("pub_chart_datasource");
                    sqlInserter.setAutoIncrementField("id");
                    sqlInserter.setData(dataSrcMap);
                    QVariant data_d = doThreadWork(new TopClassSqlThread(this), TOPSQLTHREAD_INSERT_ROW, QVariant::fromValue(sqlInserter));
                    TDataResponse dataRes_d(data_d.toMap());
                    if (dataRes_d.hasError()) {
                        unloading();
                        alertError(ttr("Import failed!"), dataRes_d.errText());
                        return;
                    }
                    graphMap.insert("chart_datasource_id", dataRes_d.data().toString());
                }
            }
            QString graphName = graphMap.value("name").toString();
            if (!graphName.isEmpty()) {
                selector.clear();
                selector.setTable("pub_chart_graph");
                selector.setWhere("name", graphName);
                QVariant pcgdata = doThreadWork(new TopClassSqlThread(this), TOPSQLTHREAD_SELECT_COUNT, QVariant::fromValue(selector));
                TDataResponse pcgDataRes(pcgdata.toMap());
                if (pcgDataRes.hasError()) {
                    unloading();
                    alertError(ttr("Import failed!"), pcgDataRes.errText());
                    return;
                }
                if (pcgDataRes.data().toInt() > 0) {
                    unloading();
                    QString ans = TMessageBox::warning(0, ttr("Chart graph: %1 already exists!").arg(dataSrcName), "", "",
                                         QStringList() << ttr("Overwrite") + ":Ok:Ok:Warn" << ttr("Skip") + ":Skip:Cancel:Normal");
                    if (ans == "Ok") {
                        updater.clear();
                        updater.setTable("pub_chart_graph");
                        updater.setData(graphMap);
                        updater.setWhere("name", graphName);
                        QVariant data_d = doThreadWork(new TopClassSqlThread(this), TOPSQLTHREAD_UPDATE_ROW, QVariant::fromValue(updater));
                        TDataResponse dataRes_d(data_d.toMap());
                        if (dataRes_d.hasError()) {
                            unloading();
                            alertError(ttr("Import failed!"), dataRes_d.errText());
                            return;
                        }
                    } else if (ans == "Skip") {
                    } else {
                        refresh();
                        mDetail->refreshGraph();
                        mDetail->refreshDatasource();
                        return;
                    }
                } else {
                    sqlInserter.clear();
                    sqlInserter.setTable("pub_chart_graph");
                    sqlInserter.setAutoIncrementField("id");
                    sqlInserter.setData(graphMap);
                    QVariant data_d = doThreadWork(new TopClassSqlThread(this), TOPSQLTHREAD_INSERT_ROW, QVariant::fromValue(sqlInserter));
                    TDataResponse dataRes_d(data_d.toMap());
                    if (dataRes_d.hasError()) {
                        unloading();
                        alertError(ttr("Import failed!"), dataRes_d.errText());
                        return;
                    }
                }
            }
        }
    }
    unloading();
    refresh();
    mDetail->refreshGraph();
    mDetail->refreshDatasource();
    TMessageBox::ok(this, ttr("Import success!"));
}

void SysChartDeveloperMgt::onSelectionChanged()
{
    QVariantList selectedItems = mTableView->selectedPrimaryKeys();
    QString uid;
    if (!selectedItems.isEmpty()) {
        uid = selectedItems.first().toString();
    }
    if (mDetail->uid() != uid) {
        mDetail->setLastUid(uid);
        if (!mDetail->isDataModified()) {
            mDetail->setUid(uid);
        }
    }
    refreshActionState();
}

void SysChartDeveloperMgt::onDetailChanged()
{
    if (mDetail->isDataModified()) {
        this->showMaskFrame(mMgtWidget);
    } else {
        this->hideMaskFrame();
    }
    refreshActionState();
}

void SysChartDeveloperMgt::onPageChanged()
{
    refresh(false);
}

void SysChartDeveloperMgt::initUi()
{
    mBodyWidget = new QWidget(this);
    this->setCentralWidget(mBodyWidget);
    mBodySplitter = new TSplitter(this);
    mBodySplitter->setOrientation(Qt::Horizontal);
    mBodyLayout = new QVBoxLayout(mBodyWidget);
    mBodyLayout->setMargin(0);
    mBodyLayout->setSpacing(0);
    mBodyLayout->addWidget(mBodySplitter);
    // tableview
    mMgtWidget = new QWidget(this);
    QVBoxLayout *mgtLayout = new QVBoxLayout(mMgtWidget);
    mgtLayout->setMargin(0);
    mgtLayout->setSpacing(0);
    // top toolbar
    if (QToolBar *toolbar = qobject_cast<QToolBar*>(uim()->getWidget("MAIN_TOOLBAR"))) {
        mgtLayout->insertWidget(0, toolbar);
        mSearchEntry = qobject_cast<TSearchEntry *>(uim()->getWidget("MAIN_TOOLBAR/SEARCH_ENTRY"));
        if (mSearchEntry != nullptr) {
            connect(mSearchEntry, SIGNAL(search(QString,QVariant)), this, SLOT(refresh()));
        }
    }
    mTableView = new TTableView(this);
    mTableView->setSelectionMode(QAbstractItemView::ExtendedSelection);
    TopClassHelper::parseTableConf0(this,"view",&mTableConf);
    mTableView->setDataKeyList(mTableConf.dataKeys);
    mTableView->setPrimaryKey(mTableConf.primaryKey);
    QVariantList headerItems = mTableConf.horizontalHeaders;
    headerItems.prepend(QVariant());
    mTableView->setHeaderItem(headerItems);
    mTableView->horizontalHeader()->setFixedHeight(40);
    QMenu *popMenu = qobject_cast<QMenu*>(uim()->getWidget("TABLEVIEW_POPUP"));
    if(popMenu) {
        mTableView->setContextMenu(popMenu);
    }
    if (mSearchEntry != nullptr) {
        mSearchEntry->setOptionList(TDataParse::headerItem2searchList(mTableView->headerItem()));
        mSearchEntry->setPlaceholderText(ttr("Search %1"));
    }
    mgtLayout->addWidget(mTableView);
    connect(mTableView->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
            this, SLOT(onSelectionChanged()));
    mBodySplitter->addWidget(mMgtWidget);
    // bottom toolbar
    if (QToolBar *toolbar = qobject_cast<QToolBar*>(uim()->getWidget("BOTTOM_TOOLBAR"))) {
        mgtLayout->addWidget(toolbar, 0);
        mPageTool = qobject_cast<TPageTool *>(uim()->getWidget("BOTTOM_TOOLBAR/PAGE_TOOL"));
        if (mPageTool != nullptr) {
            mPageTool->setPageSizeVisible(true);
            connect(mPageTool, SIGNAL(pageChanged(int,int)), this, SLOT(onPageChanged()));
        }
    }
    // detail
    mDetail = new SysChartDeveloper("sys-chart-developer", QVariantMap{}, this);
    mBodySplitter->addWidget(mDetail);
    const QStringList factors = config("view_factors","1:1").toString().split(":");
    if(factors.size() == 2) {
        const float f0 = factors[0].toFloat();
        const float f1 = factors[1].toFloat();
        const float total = f0 + f1;
        const int w = width();
        mBodySplitter->setSizes(QList<int>()
                                << static_cast<int>(w*f0/total)
                                << static_cast<int>(w*f1/total));
    }
    connect(mDetail, SIGNAL(windowModifyChanged(bool)),this,SLOT(onDetailChanged()));
}

void SysChartDeveloperMgt::initPreviewUi()
{
    mPreviewDlg = new TDialog(this);
    mPreviewDlg->setProperty("SS_BG","PANEL");
    mPreviewDlg->setWindowIcon(TRES->icon("bar-chart-o"));
    mPreviewDlg->setWindowTitle(ttr("Preview"));
    //mPreviewDlg->setAttribute(Qt::WA_DeleteOnClose, true);
    mChartNaviWgt = new SysChartNavigation("sys-chart-navigation");
    QVBoxLayout *dlgLayout = new QVBoxLayout(mPreviewDlg);
    dlgLayout->setMargin(0);
    dlgLayout->setSpacing(0);
    if (mChartNaviWgt) {
        dlgLayout->addWidget(mChartNaviWgt);
    }
    mPreviewDlg->resize(800, 600);
    mPreviewDlg->hide();
}

void SysChartDeveloperMgt::initSpecifiedClass()
{
    t::loading(this);
    TSqlSelectorV2 selector;
    selector.setTable("pub_conf");
    selector.setField("text_data");
    selector.setWhere("path", "navigation_specified_class");
    QVariant data = doThreadWork(new TopClassSqlThread(this), TOPSQLTHREAD_SELECT_VALUE, QVariant::fromValue(selector));
    unloading();
    TDataResponse dataRes(data.toMap());
    if (dataRes.hasError()) {
        alertError(dataRes.errText(), "Error");
        return;
    }
    mSpecifiedClass = dataRes.data().toString();
    mDetail->setSpecifiedClass(mSpecifiedClass);
    qDebug()<<"Specified Class: "<< mSpecifiedClass;
}

TSqlSelectorV2 SysChartDeveloperMgt::getSqlSelector(bool iResetPageBol)
{
    TSqlSelectorV2 selector;
    if(mTableConf.dbTableName.isEmpty()) {
        selector.setTable("pub_chart_navigation");
    } else {
        selector.setTable(mTableConf.dbTableName);
    }
    selector.setReturnRowCount(true);
    selector.setField(mTableConf.queryFields);
    int pageNumInt = 1;
    int pageSizeInt = -1;
    if (mPageTool != nullptr) {
        if (iResetPageBol) {
            mPageTool->setCurrentPage(1, true);
        }
        pageNumInt = mPageTool->currentPage();
        pageSizeInt = mPageTool->pageSize();
    }
    if (!mSpecifiedClass.isEmpty()) {
        selector.setWhere("class", mSpecifiedClass);
    }
    if (mSearchEntry != nullptr) {
        selector.whereRef().append(mSearchEntry->sqlWhere());
    }
    selector.setOrder("id", Qt::AscendingOrder);
    if (pageNumInt < 1) {
        pageNumInt = 1;
    }
    if (pageSizeInt < 1) {
        pageSizeInt = 100;
    }
    if (mPageTool != nullptr) {
        selector.setPage(pageNumInt, pageSizeInt);
    }
    return selector;
}

QStringList SysChartDeveloperMgt::extractDir(const QString &iPath)
{
    QStringList retList;
    QDir dir(iPath);
    if (!dir.exists()) {
        return retList;
    }
    dir.setFilter(QDir::Dirs | QDir::Files);
    dir.setSorting(QDir::DirsFirst);
    QFileInfoList list = dir.entryInfoList();
    int i = 0;
    do {
        QFileInfo fileInfo = list.at(i);
        if (fileInfo.fileName() == "." | fileInfo.fileName() == "..") {
            i++;
            continue;
        }
        bool isDir = fileInfo.isDir();
        if (isDir) {
            retList.append(extractDir(fileInfo.filePath()));
        } else {
            QString fileName = fileInfo.absoluteFilePath();
            if (fileName.endsWith(".chart.json", Qt::CaseInsensitive)) {
                retList.append(fileName);
            }
        }
        i++;
    } while (i < list.size());
    return retList;
}

MultiFileSelect::MultiFileSelect(QWidget *parent) :
    QFileDialog(parent)
{
}
void  MultiFileSelect::go()
{
    QDialog::accept();
}