ts/TransmitterSwitch/transmitterswitch.cpp

#include "transmitterswitch.h"
#include "ui_transmitterswitch.h"


#include <QFile>
#include <QList>
#include <memory>
#include <QLayout>
#include <QScrollBar>

#include "LHQLogAPI.h"
#include "pBtnUserData2.h"
#include "WebAPI/FromWebAPI.h"
#include "TransmitterSwitchInfo.h"
#include "savetotemplate.h"
#include "importtemplate.h"
#include "warning.h"
#include "tipwidget.h"
#include "UIStyleManager.h"
#include "PlanData.h"
#include "plancard.h"
#include "flowlayout.h"
#include "managerplan.h"
#include "importtemplate.h"
#include "copytoother.h"
#include "templatemanager.h"



TransmitterSwitch::TransmitterSwitch(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::TransmitterSwitch)
{
    ui->setupUi(this);
    m_widgetParent = parent;

    /* 创建一个布局 */
    QVBoxLayout* layout = new QVBoxLayout(parent);
    layout->setMargin(0);
    layout->setSpacing(0);
    parent->setLayout(layout);
    layout->addWidget(this);

    /* 创建一个流式布局，存放卡片 */
    m_flowlayout = new FlowLayout(ui->scrollAreaContents_Card, 0, m_cardHorSpacing, m_cardVerSpacing);
    // m_flowlayout->setContentsMargins(0, 0, 0, 0);
    // m_flowlayout->setSpacing(200);
    
    ui->scrollAreaContents_Card->setLayout(m_flowlayout);

    /* 创建WebAPI实例 */
    m_fromWebAPI = new FromWebAPI;

    /* 设置“默认计划”按钮可点击 */
    ui->pBtn_defaultPlan->setCheckable(true);
    ui->pBtn_allFrequency->setCheckable(true);
    connect(ui->pBtn_allFrequency, &QPushButton::clicked, this, &TransmitterSwitch::do_selectFrequencyBtn);
    

    /* 设置提示文本 */
    m_tipText = new QLabel(this);
    m_tipText->resize(936,56);
    m_tipText->setObjectName("label_TipText");
    m_tipText->setText(R"(按时刻执行模式：即以时刻点为单位进行执行，若某日既为普通日和特殊日，在某一时刻皆有执行动作，将优先执行特殊日在此时刻所计划的动作。
按天执行模式：即以天为单位进行执行，若某日既为普通日和特殊日，则当日一整天优先执行特殊日所计划的动作，普通日计划当日不再执行。)");
    m_tipText->hide();
    QPoint pos = ui->label_Tip->mapTo(this, ui->label_Tip->pos());
    m_tipText->move(pos.x() + 2, pos.y() + 2 );     /* 去掉阴影的宽度和高度 */
    ui->label_Tip->installEventFilter(this);

    /* 设置默认值 */
    ui->pBtn_defaultPlan->setChecked(true);
    ui->rBtn_moment->setChecked(true);


    /* 连接信号和槽 */
    connect(ui->pBtn_addPlan, &QPushButton::clicked, this, &TransmitterSwitch::do_pBtnAddExecPlan);
    connect(ui->pBtn_importPlan, &QPushButton::clicked, this, &TransmitterSwitch::do_importData);
    connect(ui->pBtn_exportPlan, &QPushButton::clicked, this, &TransmitterSwitch::do_exportData);
    connect(ui->pBtn_editPlan, &QPushButton::clicked, this, &TransmitterSwitch::do_pBtnModifyExecPlan);
    connect(ui->pBtn_refresh, &QPushButton::clicked, this, &TransmitterSwitch::do_pBtnRefresh);
    connect(ui->pBtn_defaultPlan, &QPushButton::clicked, this, &TransmitterSwitch::do_pBtnIsOpenPlan);
    connect(ui->rBtn_moment, &QPushButton::clicked, this, &TransmitterSwitch::do_pBtnExecMode);
    connect(ui->rBtn_day, &QPushButton::clicked, this, &TransmitterSwitch::do_pBtnExecMode);
    // connect(ui->pBtn_clearPlan, &QPushButton::clicked, this, &TransmitterSwitch::do_pBtnClearPlan);
    connect(ui->pBtn_deletePlan, &QPushButton::clicked, this, &TransmitterSwitch::do_pBtnClearPlan);
    connect(ui->pBtn_cloneToOther, &QPushButton::clicked, this, &TransmitterSwitch::do_pBtnCopyToOther);
    connect(ui->pBtn_templateManager, &QPushButton::clicked, this, &TransmitterSwitch::do_pBtnManageTemplate);

    /* 设置QSS */
    connect(&EPUIStyle, &UIStyleManager::signal_qssChanged, this, &TransmitterSwitch::do_setUIStyle);
    /* 设置默认的皮肤 */
    EPUIStyle.setUIStyle(enum_UIStyle::UI_Dark);

    /* 设置默认点击的按钮 */
    ui->pBtn_allFrequency->setChecked(true);

}

TransmitterSwitch::~TransmitterSwitch()
{
    if(m_tipText != nullptr)
    {
        delete m_tipText;
        m_tipText = nullptr;
    }
    delete ui;
}


/* 设置样式表路径，给弹窗页面使用，不需要包含最后的white，black */
void TransmitterSwitch::setQSSPath(const QString &qssPath)
{
    if(qssPath.isEmpty())
    {
        return;
    }
    /* 去掉最后的“/” */
    // if(qssPath.endsWith("/"))
    // {
    //     EPUIStyle.setQSSPath(qssPath.left(qssPath.length() - 1));
    // } else
    // {
    //     EPUIStyle.setQSSPath(qssPath);
    // }
}

/**
 * @brief 设置WebAPI信息
 * 
 * @param url WebAPI地址
 * @param serID 数据库ID
 * @param serKey 限制的关键字
 */
void TransmitterSwitch::setWebAPIInfo(const QString &url, const QString &serverID, const QString &serverKey)
{
    if(m_fromWebAPI == nullptr)
    {
        m_fromWebAPI = new FromWebAPI;
    }
    if(url.isEmpty() || serverID.isEmpty() || serverKey.isEmpty())
    {
        LH_WRITE_ERROR("WebAPI info is empty");
        return;
    }
    m_fromWebAPI->initWebApi(url, serverID, serverKey);
    /* 获取支持的设备 */
    // m_fromWebAPI->getDeviceInfo(DeviceContainer.getMapDevice());
    m_fromWebAPI->getChannelInfo(ChnContainer.getMapChannel());

    /* 创建获取到的卡片信息 */
    createAllCard();
}

/* 初始化webAPI，重载版 */
void TransmitterSwitch::setWebAPIInfo(const InitData& data)
{
    setWebAPIInfo(data.url, data.serverID, data.serverKey);
}

/**
 * @brief 获取EQM数据库计划，包括所有的配置信息
 * 
 */
void TransmitterSwitch::getExecPlanFromEQM()
{
    /* 获取页面的配置信息 */
    if(m_fromWebAPI->getConfigData(CfgData.getMapConfigData()))
    {
        // TipWidget::display(TipWidget::OPERATOR_OK, "获取配置成功", this);
    }else {
        TipWidget::display(TipWidget::OPERATOR_FAIL, "获取配置失败", this);
        return;
    }
    /* 设置计划配置 */
    auto& mapConfig = CfgData.getMapConfigData();
    for(auto begin = mapConfig.begin(), end = mapConfig.end(); begin != end; begin++)
    {
        if(begin->key == static_cast<int>(enum_ExecPlanConfig::OpenPlan))
        {
            ui->pBtn_defaultPlan->setChecked(begin->value == 1 ? true : false);
        }
        else if(begin->key == static_cast<int>(enum_ExecPlanConfig::ExecMode))
        {
            if(begin->value == 0)
            {
                ui->rBtn_moment->setChecked(true);
            }else {
                ui->rBtn_day->setChecked(true);
            }
        }
    }

    /* 获取所有频率的计划 */
    // bool isSuccess = true;
    // for(const auto& chn : ChnContainer.getMapChannel())
    // {
    //     /* 获取计划 */
    //     QList<OnePlanItemInfo> list;
    //     if(m_fromWebAPI->getExecPlanData(chn.ChannelID, list))
    //     {
    //         auto pCard = PData.findPlanCard(chn.ChannelID);
    //         if(pCard != nullptr)
    //         {
    //             pCard->setPlanList(list);
    //         }
    //     }else {
    //         TipWidget::display(TipWidget::OPERATOR_FAIL, QString("获取频率<%1>计划失败").arg(chn.ChannelName), this);
    //         isSuccess = false;
    //         LH_WRITE_ERROR(QString("获取频率“%1”计划失败").arg(chn.ChannelName));
    //     }
    //     /* 先显示已获取到的数据，避免等待时间太久，卡顿 */
    //     QEventLoop loop;
    //     loop.processEvents();
    // }

    QMap<int, QList<OnePlanItemInfo>> mapPlan;
    if(m_fromWebAPI->getExecPlanData(mapPlan))
    {
        /* 先清空所有的计划 */
        PData.clearAllPlanItem();
        /* 遍历所有的频率 */
        for(auto begin = mapPlan.begin(), end = mapPlan.end(); begin != end; begin++)
        {
            auto pCard = PData.findPlanCard(begin.key());
            if(pCard != nullptr)
            {
                pCard->setPlanList(begin.value());
            }
        }
        TipWidget::display(TipWidget::OPERATOR_OK, "获取计划成功", this);
    }else {
        TipWidget::display(TipWidget::OPERATOR_FAIL, QString("获取计划失败"), this);
    }

    /* 调用回调函数 */
    if(m_trackCB != nullptr)
    {
        m_trackCB(2, g_mapTrack.value(2));
    }
}

/* 将计划保存到EQM数据库 */
void TransmitterSwitch::saveExecPlanToEQM()
{
    QList<OnePlanItemInfo> list;
    /* 获取当前计划的执行模式 */
    int execType = 0;
    if(ui->rBtn_moment->isChecked())
    {
        execType = 0;
    } else
    {
        execType = 1;
    }
    // for(const auto& it : IData.getMapItem())
    // {
    //     for(const auto& it1 : *it)
    //     {
    //         OnePlanItemInfo info;
    //         info.ExecType = execType;
    //         info.devName = it1->getDevName();
    //         info.actionID = it1->getActionNum();
    //         info.actionName = it1->getActionName();
    //         info.execTime = it1->getExecTime();
    //         info.date = it1->getDate();
    //         info.WeekDay = it1->getWeekDay() + 1;
    //         list.push_back(info);
    //     }
    // }
    /* 写入数据库 */
    // if(m_fromWebAPI->insertData(list))
    // {
    //     TipWidget::display(TipWidget::OPERATOR_OK, "保存计划成功", this);
    // }else {
    //     TipWidget::display(TipWidget::OPERATOR_FAIL, "保存计划失败", this);
    // }

    /* 保存“默认计划”和“执行模式” */
    ConfigData config1;
    config1.key = static_cast<int>(enum_ExecPlanConfig::OpenPlan);
    config1.value = ui->pBtn_defaultPlan->isChecked() ? 1 : 0;
    config1.updateTime = QDateTime::currentDateTime();
    CfgData.updateConfigData(config1);
    
    ConfigData config2;
    config2.key = static_cast<int>(enum_ExecPlanConfig::ExecMode);
    config2.value = ui->rBtn_moment->isChecked() ? 0 : 1;
    config2.updateTime = QDateTime::currentDateTime();
    CfgData.updateConfigData(config2);

    /* 更新“计划是否更新”标志位，在更新前需要先获取数据库的标志位，如果依旧为1，那么本地是否更改都设置为1 */
    ConfigData config3;
    if(!m_fromWebAPI->getConfigData(static_cast<int>(enum_ExecPlanConfig::IsChanged), config3))
    {
        config3.key = static_cast<int>(enum_ExecPlanConfig::IsChanged);
    }
    /* 只要数据库和本地更新标志位有一个为true，说明还未被读走，则设置标志位为true */
    // if((config3.value == 1) || IData.isUpdate())
    // {
    //     config3.value = 1;
    // }
    config3.updateTime = QDateTime::currentDateTime();
    CfgData.updateConfigData(config3);

    /* 将配置写入数据库 */
    m_fromWebAPI->insertConfigData(CfgData.getMapConfigData());

    /* 调用回调函数 */
    if(m_trackCB != nullptr)
    {
        m_trackCB(1, g_mapTrack.value(1));
    }

}

/* 亮/暗换肤，0是亮色，1是暗色 */
void TransmitterSwitch::setUIStyle(int style)
{
    if(style == 0)
    {
        EPUIStyle.setUIStyle(enum_UIStyle::UI_Light);
    }
    else if(style == 1)
    {
        EPUIStyle.setUIStyle(enum_UIStyle::UI_Dark);
    }else {
        LH_WRITE_ERROR(QString("错误的样式类型: %1").arg(style));
    }
}

/* 设置回调函数 */
void TransmitterSwitch::setTrackCallBack(trackCallBack cb)
{
    if(cb == nullptr)
    {
        return;
    }
    m_trackCB = cb;
}


/* 点击了添加计划按钮 */
void TransmitterSwitch::do_pBtnAddExecPlan()
{
    /* 创建新增窗口 */
    std::shared_ptr<ManagerPlan> mp = std::make_shared<ManagerPlan>(Enum_Mode::Mode_Add);

    /* 获取当前选中的窗口 */
    auto pCard = PData.getCurrentPlanCard();
    ChannelInfo chnInfo;
    if(pCard == nullptr)
    {
        LH_WRITE_LOG_DEBUG("没有选中频率卡片");
    }else {
        mp->setFrequencyID(pCard->getChannelInfo());
    }
    connect(mp.get(), &ManagerPlan::signal_saveTemplate, this, &TransmitterSwitch::do_exportDataToEQM);
    mp->exec();

    /* 判断是否点击了OK */
    if(!mp->isOK())
    {
        return;
    }
    /* 获取计划信息 */
    auto& mapPlanInfo = mp->getPlanInfo();
    /* 遍历所有的频率 */
    bool isSuccess = true;
    for(auto begin = mapPlanInfo.begin(), end = mapPlanInfo.end(); begin != end; begin++)
    {
        /* 获取频率ID */
        int chnID = begin.key();
        /* 获取计划列表 */
        auto& list = begin.value();
        /* 查找这个频率的Card */   
        auto pCard = PData.findPlanCard(chnID);
        if(pCard == nullptr)
        {
            LH_WRITE_ERROR(QString("没有找到频率ID为%1的卡片").arg(chnID));
            continue;
        }
        /* 设置计划列表 */
        pCard->setPlanList(list);
        /* 写入数据库 */
        QList<OnePlanItemInfo> listPlan;
        pCard->getAllPlanInfo(listPlan);
        if(!m_fromWebAPI->insertData(chnID, listPlan))
        {
            LH_WRITE_ERROR(QString("频率ID为%1的计划写入数据库失败").arg(chnID));
            isSuccess = false;
            TipWidget::display(TipWidget::OPERATOR_FAIL, QString("频率:%1 计划写入数据库失败!").arg(pCard->getChannelInfo().ChannelName), this);
        }
    }
    if(isSuccess)
    {
        TipWidget::display(TipWidget::OPERATOR_OK, "添加计划成功", this);
    }
}

/* 点击了修改按钮 */
void TransmitterSwitch::do_pBtnModifyExecPlan()
{
    /* 创建新增窗口 */
    std::shared_ptr<ManagerPlan> mp = std::make_shared<ManagerPlan>(Enum_Mode::Mode_Modify);
    auto pCard = PData.getCurrentPlanCard();
    if(pCard == nullptr)
    {
        LH_WRITE_ERROR("没有选中频率卡片");
        return;
    }
    /* 设置频率信息 */
    mp->setFrequencyID(pCard->getChannelInfo());
    connect(mp.get(), &ManagerPlan::signal_saveTemplate, this, &TransmitterSwitch::do_exportDataToEQM);

    mp->exec();

    /* 判断是否点击了OK */
    if(!mp->isOK())
    {
        return;
    }
    /* 获取计划信息 */
    auto& mapPlanInfo = mp->getPlanInfo();
    auto list = mapPlanInfo.find(pCard->getChannelInfo().ChannelID);
    pCard->setPlanList(*list);

    int chnID = pCard->getChannelInfo().ChannelID;
    QList<OnePlanItemInfo> listPlan;
    pCard->getAllPlanInfo(listPlan);
    if(!m_fromWebAPI->insertData(chnID, listPlan))
    {
        LH_WRITE_ERROR(QString("频率ID为%1的计划写入数据库失败").arg(chnID));
        TipWidget::display(TipWidget::OPERATOR_FAIL, QString("频率<%1>计划写入数据库失败").arg(pCard->getChannelInfo().ChannelName), this);
    }
    TipWidget::display(TipWidget::OPERATOR_OK, "修改计划成功", this);
    /* 调用回调函数 */
    if(m_trackCB != nullptr)
    {
        m_trackCB(1, g_mapTrack.value(1));
    }
}


/* 点击了刷新按钮 */
void TransmitterSwitch::do_pBtnRefresh()
{
    getExecPlanFromEQM();
}

/* 点击了“是否开启计划”按钮 */
void TransmitterSwitch::do_pBtnIsOpenPlan()
{
    /* 保存“默认计划”和“执行模式” */
    ConfigData config1;
    config1.key = static_cast<int>(enum_ExecPlanConfig::OpenPlan);
    config1.value = ui->pBtn_defaultPlan->isChecked() ? 1 : 0;
    config1.updateTime = QDateTime::currentDateTime();
    CfgData.updateConfigData(config1);

    /* 更新“计划是否更新”标志位，在更新前需要先获取数据库的标志位，如果依旧为1，那么本地是否更改都设置为1 */
    ConfigData config3;
    if(!m_fromWebAPI->getConfigData(static_cast<int>(enum_ExecPlanConfig::IsChanged), config3))
    {
        config3.key = static_cast<int>(enum_ExecPlanConfig::IsChanged);
    }
    /* 只要数据库和本地更新标志位有一个为true，说明还未被读走，则设置标志位为true */
    config3.value = 1;
    config3.updateTime = QDateTime::currentDateTime();
    CfgData.updateConfigData(config3);

    /* 将配置写入数据库 */
    m_fromWebAPI->insertConfigData(CfgData.getMapConfigData());
}

/* 点击了“执行模式”按钮 */
void TransmitterSwitch::do_pBtnExecMode()
{
    /* 保存“默认计划”和“执行模式” */
    ConfigData config1;
    config1.key = static_cast<int>(enum_ExecPlanConfig::ExecMode);
    config1.value = ui->rBtn_moment->isChecked() ? 0 : 1;
    config1.updateTime = QDateTime::currentDateTime();
    CfgData.updateConfigData(config1);

    /* 更新“计划是否更新”标志位，在更新前需要先获取数据库的标志位，如果依旧为1，那么本地是否更改都设置为1 */
    ConfigData config3;
    if(!m_fromWebAPI->getConfigData(static_cast<int>(enum_ExecPlanConfig::IsChanged), config3))
    {
        config3.key = static_cast<int>(enum_ExecPlanConfig::IsChanged);
    }
    /* 只要数据库和本地更新标志位有一个为true，说明还未被读走，则设置标志位为true */
    config3.value = 1;
    config3.updateTime = QDateTime::currentDateTime();
    CfgData.updateConfigData(config3);

    /* 将配置写入数据库 */
    m_fromWebAPI->insertConfigData(CfgData.getMapConfigData());
}

/* 点击了清空计划按钮 */
void TransmitterSwitch::do_pBtnClearPlan()
{
    /* 先判断有没有选中的频率卡片 */
    if(PData.getCurrentPlanCard() == nullptr)
    {
        TipWidget::display(TipWidget::OPERATOR_FAIL, "没有选中频率卡片", this);
        return;
    }
    /* 跳出弹窗警告 */
    Warning w(this);
    w.setQSS(EPUIStyle.getQSSPath());
    w.setText("确定删除对应频率开关机计划？");
    bool flag = false;
    connect(&w,&Warning::signal_ok,this,[&](){
        flag = true;
    });
    w.exec();
    if(!flag)
    {
        return;
    }
    /* 获取选中的卡片 */
    auto pCard = PData.getCurrentPlanCard();
    if(pCard == nullptr)
    {
        LH_WRITE_ERROR("没有选中频率卡片");
        return;
    }
    /* 清空计划 */
    pCard->clearPlanItem();
    /* 删除数据库中的计划 */
    if(!m_fromWebAPI->deleteOneChnPlan(pCard->getChannelInfo().ChannelID))
    {
        LH_WRITE_ERROR(QString("频率ID为%1的计划删除失败").arg(pCard->getChannelInfo().ChannelID));
        TipWidget::display(TipWidget::OPERATOR_FAIL, QString("频率<%1>计划删除失败").arg(pCard->getChannelInfo().ChannelName), this);
    }else {
        TipWidget::display(TipWidget::OPERATOR_OK, "清空计划成功", this);
    }
}

/* 点击了复制到其他频率按钮 */
void TransmitterSwitch::do_pBtnCopyToOther()
{
    /* 先判断有没有选中的频率卡片 */
    auto pCard = PData.getCurrentPlanCard();
    if(pCard == nullptr)
    {
        TipWidget::display(TipWidget::OPERATOR_WARN, "没有选中频率卡片", this);
        return;
    }
    /* 判断卡片有没有计划 */
    if(pCard->isPlanEmpty())
    {
        TipWidget::display(TipWidget::OPERATOR_WARN, "当前频率没有计划", this);
        return;
    }

    std::shared_ptr<CopyToOther> cto = std::make_shared<CopyToOther>(this);
    cto->setQSSPath(EPUIStyle.getQSSPath());
    cto->setFrequencyList(pCard->getChannelInfo(), ChnContainer.getMapChannel());
    cto->exec();

    /* 判断有没有点击OK */
    if(!cto->isOk())
    {
        return;
    }
    /* 获取选中的频率列表 */
    auto list = cto->getSelectedFrequencyList();
    /* 获取当前频率的计划列表 */
    QList<PlanInfo> listPlan;
    pCard->getPlanList(listPlan);
    /* 遍历所有的频率 */
    bool isSuccess = true;
    for(auto& it : list)
    {
        auto pTmpCard = PData.findPlanCard(it.ChannelID);
        if(pTmpCard == nullptr)
        {
            LH_WRITE_ERROR(QString("没有找到频率ID为%1的卡片").arg(it.ChannelID));
            continue;
        }
        /* 设置计划列表 */
        pTmpCard->setPlanList(listPlan);
        QList<OnePlanItemInfo> tmpListPlan;
        pTmpCard->getAllPlanInfo(tmpListPlan);
        /* 写入数据库 */
        if(!m_fromWebAPI->insertData(it.ChannelID, tmpListPlan))
        {
            LH_WRITE_ERROR(QString("频率ID为%1的计划写入数据库失败").arg(it.ChannelID));
            TipWidget::display(TipWidget::OPERATOR_FAIL, QString("频率<%1>计划写入数据库失败").arg(it.ChannelName), this);
            isSuccess = false;
        }
    }
    if(isSuccess)
    {
        TipWidget::display(TipWidget::OPERATOR_OK, "复制计划成功", this);
    }
}


/* 点击了管理模板按钮 */
void TransmitterSwitch::do_pBtnManageTemplate()
{
    QMultiMap<int, OneTemplateInfo> tabList;

    // OneTemplateInfo testInfo;
    // testInfo.channelInfo.ChannelID = 1;
    // testInfo.channelInfo.ChannelName = "测试频率1";
    // testInfo.templateName = "模版1";
    // tabList.insert(testInfo.channelInfo.ChannelID, testInfo);

    // testInfo.channelInfo.ChannelID = 1;
    // testInfo.channelInfo.ChannelName = "测试频率2";
    // testInfo.templateName = "模版2";
    // tabList.insert(testInfo.channelInfo.ChannelID, testInfo);

    /* 获取全部的频率 */
    if(!m_fromWebAPI->getTemplateList(tabList))
    {
        TipWidget::display(TipWidget::OPERATOR_FAIL, "获取模版列表失败", this);
        return;
    }
    
    /* 将模板列表添加频率信息 */
    for(auto it = tabList.begin(), end = tabList.end(); it != end; it++)
    {
        auto chnInfo = ChnContainer.getChannel(it->channelInfo.ChannelID);
        it->channelInfo = chnInfo;
    }

    std::shared_ptr<TemplateManager> tm = std::make_shared<TemplateManager>();
    tm->setQSSPath(EPUIStyle.getQSSPath());
    tm->setTemplateList(tabList);
    tm->setWebAPI(m_fromWebAPI);
    // connect(tm.get(), &TemplateManager::signal_deleteTemplate, this, &TransmitterSwitch::do_deleteTemplate);
    tm->exec();

    /* 判断是否点击了OK */
    if(!tm->isOk())
    {
        return;
    }
    bool isSuccess = true;
    /* 获取删除的计划列表 */
    auto list = tm->getDeleteTemplateList();
    if(!m_fromWebAPI->deleteTemplateList(list))
    {
        LH_WRITE_ERROR("删除模版失败");
        TipWidget::display(TipWidget::OPERATOR_FAIL, "删除模版失败", this);
        isSuccess = false;
    }

    /* 更新模版列表 */
    auto mapTmp = tm->getModifyTemplateList();
    if(!m_fromWebAPI->modifyTemplateList(mapTmp))
    {
        LH_WRITE_ERROR("修改模版失败");
        TipWidget::display(TipWidget::OPERATOR_FAIL, "修改模版失败", this);
        isSuccess = false;
    }

    /* 更新模板名称 */
    auto mapTmpName = tm->getModifyTemplateNameList();
    if(!m_fromWebAPI->updateTemplateName(mapTmpName))
    {
        LH_WRITE_ERROR("修改模版名称失败");
        TipWidget::display(TipWidget::OPERATOR_FAIL, "修改模版名称失败", this);
        isSuccess = false;
    }
    
    if(isSuccess)
    {
        TipWidget::display(TipWidget::OPERATOR_OK, "修改模版成功", this);
    }
}


/* 导入数据 */
void TransmitterSwitch::do_importData()
{
    QMultiMap<int, OneTemplateInfo> tabList;
    /* 判断有没有选中卡片 */
    auto pCard = PData.getCurrentPlanCard();
    bool isSuccess = true;
    if(pCard == nullptr)
    {
        /* 没有选中卡片，获取全部的频率 */
        if(!m_fromWebAPI->getTemplateList(tabList))
        {
            isSuccess = false;
        }
    } else 
    {
        /* 选中了卡片，只获取这个卡片的频率列表 */
        QList<OneTemplateInfo> list;
        if(m_fromWebAPI->getTemplateList(pCard->getChannelInfo().ChannelID, list))
        {
            for(auto it = list.begin(), end = list.end(); it != end; it++)
            {
                tabList.insert(it->channelInfo.ChannelID, *it);
            }
        }else {
            isSuccess = false;
            LH_WRITE_ERROR(QString("获取频率ID为%1的模版列表失败").arg(pCard->getChannelInfo().ChannelID));
        }
    }

    if(isSuccess == false)
    {
        TipWidget::display(TipWidget::OPERATOR_FAIL, "获取模版列表失败", this);
        return;
    }
    
    /* 将模板列表添加频率信息 */
    for(auto it = tabList.begin(), end = tabList.end(); it != end; it++)
    {
        auto chnInfo = ChnContainer.getChannel(it->channelInfo.ChannelID);
        it->channelInfo = chnInfo;
    }
    std::shared_ptr<ImportTemplate> it = std::make_shared<ImportTemplate>();
    it->setQSSPath(EPUIStyle.getQSSPath());
    it->setTemplateList(tabList);

    it->exec();

    /* 判断有没有点击OK */
    if(!it->isOk())
    {
        return;
    }

    /* 获取选中的模版 */
    auto tmpList = it->getSelectedTemplateList();
    /* 判断有没有选中需要导入模版 */
    if(tmpList.isEmpty())
    {
        TipWidget::display(TipWidget::OPERATOR_WARN, "无模板导入", this);
        return;
    }

    QMap<int, QList<OnePlanItemInfo>> mapPlan;
    m_fromWebAPI->getTemplateData(tmpList, mapPlan);

    /* 将所有的模板数据插入到卡片中 */
    for(auto begin = mapPlan.begin(), end = mapPlan.end(); begin != end; begin++)
    {
        auto pCard = PData.findPlanCard(begin.key());
        if(pCard == nullptr)
        {
            LH_WRITE_ERROR(QString("没有找到频率ID为%1的卡片").arg(begin.key()));
            continue;
        }
        /* 设置计划列表 */
        pCard->setPlanList(begin.value());

        /* 写入数据库 */
        if(!m_fromWebAPI->insertData(begin.key(), begin.value()))
        {
            LH_WRITE_ERROR(QString("频率ID为%1的计划写入数据库失败").arg(begin.key()));
            TipWidget::display(TipWidget::OPERATOR_FAIL, QString("频率<%1>计划写入数据库失败").arg(pCard->getChannelInfo().ChannelName), this);
            isSuccess = false;
        }
    }

    if(isSuccess)
    {
        TipWidget::display(TipWidget::OPERATOR_OK, "导入模版成功", this);
    }
    /* 调用回调函数 */
    if(m_trackCB != nullptr)
    {
        m_trackCB(4, g_mapTrack.value(4));
    }
}

/* 导出数据 */
void TransmitterSwitch::do_exportData()
{
    /* 先获取选中的卡片 */
    auto pCard = PData.getCurrentPlanCard();
    if(pCard == nullptr)
    {
        LH_WRITE_ERROR("没有选中频率卡片");
        TipWidget::display(TipWidget::OPERATOR_WARN, "未选中频率卡片", this);
        return;
    }
    /* 判断该卡片的计划列表是否为空 */
    if(pCard->isPlanEmpty())
    {
        TipWidget::display(TipWidget::OPERATOR_WARN, "当前频率没有计划", this);
        return;
    }
    ChannelInfo info = pCard->getChannelInfo();
    do_exportDataToEQM(info);
    
}

/* 将模版写入数据库 */
void TransmitterSwitch::do_exportDataToEQM(ChannelInfo info)
{
    auto pCard = PData.findPlanCard(info.ChannelID);
    if(pCard == nullptr)
    {
        LH_WRITE_ERROR(QString("没有找到频率ID为%1的卡片").arg(info.ChannelID));
        return;
    }
    int chnID = info.ChannelID;
    /* 获取所有的模板名称 */
    QList<OneTemplateInfo> list;
    if(!m_fromWebAPI->getTemplateList(chnID, list))
    {
        LH_WRITE_ERROR(QString("获取频率ID为%1的模版列表失败").arg(chnID));
        TipWidget::display(TipWidget::OPERATOR_FAIL, "获取模版列表失败", this);
        return;
    }
    /* 弹出导出页面 */
    std::shared_ptr<SaveToTemplate> stt = std::make_shared<SaveToTemplate>();
    stt->setQSS(EPUIStyle.getQSSPath());
    stt->setTemplateList(list);
    stt->exec();
    if(!stt->isOk())
    {
        return;
    }
    /* 获取一天的数据 */
    QList<OnePlanItemInfo> listTmp;
    pCard->getAllPlanInfo(listTmp);
    /* 保存到模板 */
    if(m_fromWebAPI->saveTemplate(stt->getTemplateName(), listTmp))
    {
        TipWidget::display(TipWidget::OPERATOR_OK, "保存模版成功", this);
    }else {
        TipWidget::display(TipWidget::OPERATOR_FAIL, "保存模版失败", this);
    }
    /* 调用回调函数 */
    if(m_trackCB != nullptr)
    {
        m_trackCB(3, g_mapTrack.value(3));
    }
    
}


/* 保存计划到EQM数据库 */
void TransmitterSwitch::do_pBtn_savePlan()
{
    /* 跳出弹窗提示 */
    Warning w(this);
    w.setQSS(EPUIStyle.getQSSPath());
    w.setText("将计划保存到数据库？");
    w.exec();
    if(!w.isOk())
    {
        return;
    }
    saveExecPlanToEQM();
}

/* 删除一个模版 */
void TransmitterSwitch::do_deleteTemplate(OneTemplateInfo info)
{
    /* 删除模版 */
    if(m_fromWebAPI->deleteTemplate(info))
    {
        TipWidget::display(TipWidget::OPERATOR_OK, "删除模版成功", this);
    }else {
        TipWidget::display(TipWidget::OPERATOR_FAIL, "从数据库删除模版失败", this);
    }
}


/* 从EQM数据库获取计划 */
void TransmitterSwitch::do_pBtn_getPlan()
{
    /* 跳出弹窗提示 */
    Warning w(this);
    w.setQSS(EPUIStyle.getQSSPath());
    w.setText("从数据库获取计划，将清空当前所有的计划，请注意保存当前计划!");
    w.exec();
    if(!w.isOk())
    {
        return;
    }
    getExecPlanFromEQM();
}

/* 切换亮色/暗色外观 */
void TransmitterSwitch::do_setUIStyle()
{
    
    this->setStyleSheet(EPUIStyle.StrQSS_TransmitterSwitch);

    /* 给所有的按钮设置样式 */
    ui->pBtn_allFrequency->setStyleSheet(EPUIStyle.StrQSS_PBtnFrequency);
    // LH_WRITE_LOG(QString("频率按钮设置样式:%1").arg(EPUIStyle.StrQSS_PBtnFrequency));
}

/* 选择了一个频率按钮，取消其他的选择 */
void TransmitterSwitch::do_selectFrequencyBtn()
{
    /* 获取信号发送者 */
    auto btn = qobject_cast<QPushButton*>(sender());
    if(btn == nullptr)
    {
        return;
    }
    /* 取消其他按钮的选择 */
    for(auto& it : m_listFrequencyBtn)
    {
        if(it != btn)
        {
            it->setChecked(false);
        }
    }

    if(btn != ui->pBtn_allFrequency)
    {
        ui->pBtn_allFrequency->setChecked(false);
        /* 设置当前按钮的选择状态 */
        btn->setChecked(true);
        /* 设置该按钮对应的卡片状态 */
        auto pCard = static_cast<PBtnUserData2*>(btn->userData(m_userData_Btn))->getCard();
        pCard->clickedCard();
    }else {
        ui->pBtn_allFrequency->setChecked(true);
        /* 取消所有的卡片选择状态 */
        PData.clearAllSelectedCard();
    }

    /* 显示当前按钮对应的卡片，隐藏其他卡片 */
    showOneCard(btn);
    
}



/* 添加一个频率，包括左侧按钮和右侧卡片 */
void TransmitterSwitch::createOneCard(const ChannelInfo& chnInfo)
{
    /* 创建按钮 */
    QPushButton* pBtn = new QPushButton(this);
    pBtn->setObjectName(chnInfo.ChannelName);
    pBtn->setText(chnInfo.ChannelName);
    pBtn->setCheckable(true);
    pBtn->setMinimumHeight(40);

    PBtnUserData2* userData = new PBtnUserData2();
    userData->setChannelInfo(chnInfo);
    pBtn->setUserData(m_userData_Btn, userData);

    /* 设置按钮的样式表 */
    pBtn->setStyleSheet(EPUIStyle.StrQSS_PBtnFrequency);
    /* 连接信号和槽 */
    connect(pBtn, &QPushButton::clicked, this, &TransmitterSwitch::do_selectFrequencyBtn);
    m_listFrequencyBtn.push_back(pBtn);

    auto vLayout = qobject_cast<QVBoxLayout*>(ui->widget_frequency->layout());
    /* 减1是去掉最下面的弹簧 */
    vLayout->insertWidget(vLayout->count() - 1, pBtn);

    /* 创建卡片 */
    PlanCard* pCard = PData.createOneCard(chnInfo);
    pCard->setParent(ui->scrollAreaContents_Card);
    m_flowlayout->addWidget(pCard);
    userData->setCard(pCard);  /* 设置按钮的卡片指针 */
    /* 排序 */
}

/* 删除一个频率 */
void TransmitterSwitch::deleteOneCard(int channelID)
{
    /* 删除按钮 */
    for(auto it = m_listFrequencyBtn.begin(); it != m_listFrequencyBtn.end(); ++it)
    {
        auto userData = static_cast<PBtnUserData2*>((*it)->userData(m_userData_Btn));
        if(userData != nullptr && userData->getChannelInfo().ChannelID == channelID)
        {
            delete *it;
            m_listFrequencyBtn.erase(it);
            break;
        }
    }

    /* 删除卡片 */
    PData.deleteOneCard(channelID);
}

/* 创建所有频率卡片 */
void TransmitterSwitch::createAllCard()
{
    for(const auto& it : ChnContainer.getMapChannel())
    {
        /* 创建一个按钮和卡片 */
        createOneCard(it);
    }
}

/* 显示某个卡片，隐藏其他卡片 */
void TransmitterSwitch::showOneCard(QPushButton *btn)
{
    /* 判断是否是显示全部卡片的按钮 */
    if(btn == ui->pBtn_allFrequency)
    {
        /* 设置卡片间的横向间距 */
        m_flowlayout->setHorizontalSpacing(m_cardHorSpacing);
        /* 显示全部卡片 */
        for(auto& it : m_listFrequencyBtn)
        {
            auto ud = it->userData(m_userData_Btn);
            PBtnUserData2* userData = static_cast<PBtnUserData2*>(ud);
            if(userData != nullptr)
            {
                auto pCard = userData->getCard();
                if(pCard != nullptr)
                {
                    pCard->show();
                }
            }
        }
        /* 刷新布局，刷新了才会让FlowLayout重新布局 */
        ui->scrollAreaContents_Card->updateGeometry();
        return;
    }

    /* 设置卡片间的横向间距 */
    m_flowlayout->setHorizontalSpacing(0);
    /* 不是显示全部的按钮，隐藏所有卡片 */
    for(auto& it : m_listFrequencyBtn)
    {
        auto ud = it->userData(m_userData_Btn);
        PBtnUserData2* userData = static_cast<PBtnUserData2*>(ud);
        if(userData != nullptr)
        {
            auto pCard = userData->getCard();
            if(pCard != nullptr)
            {
                pCard->hide();
            }
        }
    }
    /* 显示当前卡片 */
    auto ud = btn->userData(m_userData_Btn);
    PBtnUserData2* userData = static_cast<PBtnUserData2*>(ud);
    if(userData != nullptr)
    {
        auto pCard = userData->getCard();
        if(pCard != nullptr)
        {
            pCard->show();
        }
    }
    /* 刷新布局，刷新了才会让FlowLayout重新布局 */
    ui->scrollAreaContents_Card->updateGeometry();
}

/* 计算并设置设置卡片大小 */
void TransmitterSwitch::setCardSize()
{
    /* 获取滚动条的区域 */
    int vsb = 0;
    if(ui->scrollArea->verticalScrollBar()->isVisible())
    {
        vsb = ui->scrollArea->verticalScrollBar()->width();
    }
    /* 去掉滚动条的宽度和阴影的宽度，再减去一个横向间距，和滚动条有些距离，不挨着太紧 */
    int saWidth = ui->scrollArea->width() - vsb - m_cardHorSpacing - 2; 
    int saHeight = ui->scrollArea->height();
    int cardWidth = ( saWidth - (m_cardHorNumber - 1) * m_cardHorSpacing ) / m_cardHorNumber;
    int cardHeight = ( saHeight - (m_cardVerNumber - 1) * m_cardVerSpacing ) / m_cardVerNumber;
    /* 设置卡片大小 */
    PData.setCardSize(cardWidth, cardHeight);

    // LH_WRITE_LOG_DEBUG(QString("卡片大小:%1*%2").arg(cardWidth).arg(cardHeight));
}

/* 计算并设置提示文本的位置 */
void TransmitterSwitch::setTipTextPos()
{
    if(m_tipText != nullptr)
    {
        QPoint pos = ui->label_Tip->mapTo(this, QPoint(0, 0));
        m_tipText->move(pos.x() - m_tipText->width(), pos.y() + 32 );
    }
}

/* 事件过滤器 */
bool TransmitterSwitch::eventFilter(QObject *watched, QEvent *event)
{
    if(watched == ui->label_Tip)
    {
        if(event->type() == QEvent::Enter)
        {
            m_tipText->show();
            return true;
        }else if(event->type() == QEvent::Leave)
        {
            m_tipText->hide();
        }
    }
    return QWidget::eventFilter(watched,event);
}


/* 窗口缩放事件 */
void TransmitterSwitch::resizeEvent(QResizeEvent *event)
{
    /* 设置提示文本的位置 */
    setTipTextPos();

    setCardSize();

    QWidget::resizeEvent(event);
}

/* 显示事件 */
void TransmitterSwitch::showEvent(QShowEvent *event)
{
    /* 设置提示文本的位置 */
    setTipTextPos();

    setCardSize();

    QWidget::showEvent(event);
}