ts/TransmitterSwitch/TransmitterSwitchInfo.cpp

#include "TransmitterSwitchInfo.h"

// #include "lhstylemanager.h"
#include <QFile>
#include <QEventLoop>

#include "spdlog/spdlog.h"

/**
 * @brief 全局的回调函数传入值和说明
 * 
 */
const QMap<int, QString> g_mapTrack = {
    {1, ""},            /* 保存计划 */
    {2, ""},            /* 加载计划 */
    {3, "保存模板"},
    {4, "导入模板"}
};


/**
 * @brief 更新一个配置，不存在则添加
 * 
 * @param data 
 */
void ConfigDataContainer::updateConfigData(const ConfigData& data)
{
    if(m_mapConfigData.contains(data.key))
    {
        m_mapConfigData[data.key].value = data.value;
        m_mapConfigData[data.key].updateTime = data.updateTime;
    }else 
    {
        /* 加入新的内容，添加说明 */
        m_mapConfigData.insert(data.key, data);
        if(KeyNotes.contains(data.key))
        {
            m_mapConfigData[data.key].notes = KeyNotes[data.key];
        }
    }
}

/* 获取一个配置 */
ConfigData& ConfigDataContainer::getConfigData(int key)
{
    if(m_mapConfigData.contains(key))
    {
        return m_mapConfigData[key];
    }
    return m_mapConfigData[0];
}

/* 查找一个配置是否在不在 */
bool ConfigDataContainer::findConfigData(int key)
{
    return m_mapConfigData.contains(key);
}

/* 删除一个配置 */
void ConfigDataContainer::deleteConfigData(int key)
{
    if(m_mapConfigData.contains(key))
    {
        m_mapConfigData.remove(key);
    }
}






OnePlanItemInfo::OnePlanItemInfo()
{
    ChannelID = -1;
    ChannelName = "";
    onWeekDay = enum_WeekDay::WeekDay_Mon;
    onDateTime = QDateTime::fromString("1970-01-01 00:00:00", "yyyy-MM-dd hh:mm:ss");
    offWeekDay = enum_WeekDay::WeekDay_Mon;
    offDateTime = QDateTime::fromString("1970-01-01 00:00:00", "yyyy-MM-dd hh:mm:ss");
}

OnePlanItemInfo::OnePlanItemInfo(const OnePlanItemInfo& item)
{
    ChannelID = item.ChannelID;
    ChannelName = item.ChannelName;
    onWeekDay = item.onWeekDay;
    onDateTime = item.onDateTime;
    offWeekDay = item.offWeekDay;
    offDateTime = item.offDateTime;
}

OnePlanItemInfo& OnePlanItemInfo::operator=(const OnePlanItemInfo& item)
{
    if(this == &item)
        return *this;
    ChannelID = item.ChannelID;
    ChannelName = item.ChannelName;
    onWeekDay = item.onWeekDay;
    onDateTime = item.onDateTime;
    offWeekDay = item.offWeekDay;
    offDateTime = item.offDateTime;
    return *this;
}

ChannelInfo::ChannelInfo(const ChannelInfo& channel)
{
    ChannelID = channel.ChannelID;
    ChannelName = channel.ChannelName;
}

ChannelInfo& ChannelInfo::operator=(const ChannelInfo& channel)
{
    if(this == &channel)
        return *this;
    ChannelID = channel.ChannelID;
    ChannelName = channel.ChannelName;
    return *this;
}

/* 添加一个频率 */
void MapChannel::addChannel(const ChannelInfo& channelInfo)
{
    m_mapChannel.insert(channelInfo.ChannelID, channelInfo);
}

/* 获取一个频率 */
ChannelInfo MapChannel::getChannel(int channelID)
{
    if(m_mapChannel.contains(channelID))
    {
        return m_mapChannel[channelID];
    }
    return ChannelInfo();
}

/* 删除除了设置频率外的其他频率信息 */
void MapChannel::deleteOtherChannel(int channelID)
{
    auto tmp = getChannel(channelID);
    // SPDLOG_INFO("删除其他频率信息，当前频率ID为:{}，频率名称为:{}", tmp.ChannelID, tmp.ChannelName.toStdString());
    m_mapChannel.clear();
    m_mapChannel.insert(channelID, tmp);
    // SPDLOG_INFO("当前频率个数为:{}", m_mapChannel.size());
}


DevTypeInfo::DevTypeInfo()
{
    devTypeName = "";
    devAction.clear();
    devType_MB.clear();
    PTTypeCode = -1;
}

DevTypeInfo& DevTypeInfo::operator=(const DevTypeInfo& devInfo)
{
    devTypeName = devInfo.devTypeName;
    devAction = devInfo.devAction;
    devType_MB = devInfo.devType_MB;
    PTTypeCode = devInfo.PTTypeCode;
    return *this;
}


MapDevType::MapDevType()
{
    initDevType();
}

/* 添加支持的设备类型 */
void MapDevType::initDevType()
{
    /* 955发射机 */
    DevTypeInfo devInfo;
    devInfo.devTypeName = "衢州台发射机";
    devInfo.PTTypeCode = 955;
    devInfo.devAction[1] = "开机";
    devInfo.devAction[2] = "关机";
    devInfo.devType_MB.insert(enum_DeviceMB::Dev_Main,"主");
    devInfo.devType_MB.insert(enum_DeviceMB::Dev_Backup,"备");
    devInfo.devType_MB.insert(enum_DeviceMB::Dev_Contingency,"应急");
    m_mapDevType.insert(955, devInfo);

    /* 其他发射机 */
}

/* 获取某一个发射机类型 */
DevTypeInfo MapDevType::getDevType(int PTTypeCode)
{
    if(m_mapDevType.contains(PTTypeCode))
    {
        return m_mapDevType[PTTypeCode];
    }
    return DevTypeInfo();
}


DeviceInfo::DeviceInfo()
{
    devName = "未定义";
    PTTypeCode = -1;
    DevType = DevTypeInfo();
    DTID = 0;
    DID = 0;
    ChannelID = 0;
}

DeviceInfo::DeviceInfo(const DeviceInfo& devInfo)
{
    devName = devInfo.devName;
    PTTypeCode = devInfo.PTTypeCode;
    DevType = devInfo.DevType;
    DTID = devInfo.DTID;
    DID = devInfo.DID;
    MPID = devInfo.MPID;
    ChannelID = devInfo.ChannelID;
}

DeviceInfo& DeviceInfo::operator=(const DeviceInfo& devInfo)
{
    devName = devInfo.devName;
    PTTypeCode = devInfo.PTTypeCode;
    DevType = devInfo.DevType;
    DTID = devInfo.DTID;
    DID = devInfo.DID;
    MPID = devInfo.MPID;
    ChannelID = devInfo.ChannelID;
    return *this;
}


MapDevice::MapDevice()
{

}

/* 添加一个设备 */
void MapDevice::addDevice(const DeviceInfo& devInfo)
{
    /* 先查重 */
    if(m_mapDevice.contains(devInfo.devName))
    {
        return;
    }
    m_mapDevice.insert(devInfo.devName, devInfo);
}

/* 获取一个设备 */
DeviceInfo MapDevice::getDevice(const QString& devName)
{
    if(m_mapDevice.contains(devName))
    {
        return m_mapDevice[devName];
    }
    return DeviceInfo();
}

/* 查找一个设备 */
bool MapDevice::findDevice(const QString& devName)
{
    return m_mapDevice.contains(devName);
}

/* 根据设备名称获取设备动作 */
bool MapDevice::getDevAction(const QString& devName, QMap<int, QString>& devAction)
{
    if(m_mapDevice.contains(devName))
    {
        devAction = m_mapDevice[devName].DevType.devAction;
        return true;
    }
    return false;
}

/* 删除一个设备 */
void MapDevice::deleteDevice(const QString& devName)
{
    if(m_mapDevice.contains(devName))
    {
        m_mapDevice.remove(devName);
    }
}

OneTemplateInfo::OneTemplateInfo(const OneTemplateInfo& info)
{
    channelInfo = info.channelInfo;
    templateName = info.templateName;
}

OneTemplateInfo& OneTemplateInfo::operator=(const OneTemplateInfo& info)
{
    if(this == &info)
        return *this;
    channelInfo = info.channelInfo;
    templateName = info.templateName;
    return *this;
}

bool OneTemplateInfo::operator<(const OneTemplateInfo& info) const
{
    if(this == &info)
        return false;
    if(channelInfo.ChannelID < info.channelInfo.ChannelID)
    {
        return true;
    }else if(channelInfo.ChannelID == info.channelInfo.ChannelID)
    {
        if(templateName < info.templateName)
        {
            return true;
        }
    }
    return false;
}


bool OneTemplateInfo::operator==(const OneTemplateInfo& info) const
{
    if(this == &info)
        return true;
    if(channelInfo.ChannelID == info.channelInfo.ChannelID && templateName == info.templateName)
    {
        return true;
    }
    return false;
}



GlobalInfo::GlobalInfo()
{
    channelInfo.ChannelID = -1;
    channelInfo.ChannelName = "";
    m_oneFrequency = false;
}