GUI/src/json/jsonobject.cpp

#include "jsonobject.h"

#include <fstream>
#include <sstream>
#include <QDateTime>
#include <vector>
#include <QTranslator>
#include <QDebug>
#include <QApplication>
#include "json/cJSON.h"

namespace
{
    const char* strProductFileName = "./cfgs/usct-product.json";
    const char* strProductFileNameDefault = "./cfgs/usct-product";
    const QString DEFAULT_RECON_TRANSFER_PATH = "/home/eq9/Tools/ReconTest/storage/Raw";
}

JsonObject::JsonObject()
{
	loadcfg();
    init();
}

JsonObject::~JsonObject()
{
    //savecfg();
}

void JsonObject::init()
{
    char* defaultUser = getJsonString("login", "defaultUser");
    mDefaultUser = defaultUser;

    cJSON* first = cJSON_GetObjectItem((cJSON*)json_root, "protocol");
    cJSON* second = cJSON_GetObjectItem(first, "lists");
    if(nullptr != first && nullptr!= second)
    {
        std::string protocals = second->valuestring;
        mProtocalList = QString::fromLocal8Bit(QByteArray::fromRawData(protocals.c_str(), protocals.size())).split(";");
    }

    mDefaultProtocal = QString(getJsonString("protocol", "default")).toInt();

    first = cJSON_GetObjectItem((cJSON*)json_root, "general");
    second = cJSON_GetObjectItem(first, "lockScreenTimes");
    if(nullptr != first && nullptr!= second)
    {
         std::string times = second->valuestring;
         mLockScreenTimeList = QString::fromLocal8Bit(QByteArray::fromRawData(times.c_str(), times.size())).split(";");
    }

    first = cJSON_GetObjectItem((cJSON*)json_root, "general");
    second = cJSON_GetObjectItem(first, "language");
    if(nullptr != first && nullptr!= second)
    {
         std::string lagunage = second->valuestring;
         mLanguageList = QString::fromLocal8Bit(QByteArray::fromRawData(lagunage.c_str(), lagunage.size())).split(";");
    }

    mDefaultLanguage = getJsonString("general", "defaultlanguage");
    mInstitutionName = getJsonString("general", "institutionName");
    mInstitutionAddr = getJsonString("general", "institutionAddr");
    mLockScreenTime = QString(getJsonString("general", "lockscreen")).toInt();
    mStorageAlarmSize = getJsonString("storagepolicy", "mininum");
    mInterfaceName = QString(getJsonString("address", "device"));
    mGateway = QString(getJsonString("routing", "defaultgateway"));
    mScanConfirm = getBool("general","ScanConfirm");
    mCompleteNotify = getBool("general","CompleteNotify");
    mAnonymousMode = getBool("general","AnonymousMode");
    mScreenSaverMode = getBool("screensaver","open");
    mScreenSaverInfoList = QString(getJsonString("screensaver", "content")).split(";");
    mDmsSimulator = getBool("dms","simulator");
    mOperationLogExpireDays = QString(getJsonString("operatorlog", "expire")).toInt();
    mPatientListExpireDays = QString(getJsonString("patientlist", "expire")).toInt();
    mScanListExpireDays = QString(getJsonString("reconlist", "expire")).toInt();

    mWorklistHost.ae = QString(getJsonString("worklist", "ae"));
    mWorklistHost.ip = QString(getJsonString("worklist", "ip"));
    mWorklistHost.localAE = QString(getJsonString("worklist", "localAE"));
    mWorklistHost.port = QString(getJsonString("worklist", "port"));
    mWorklistFilterModality = QString(getJsonString("worklistfilter","modality"));
    mWorklistFilterDays = QString(getJsonString("worklistfilter","date"));

    mPacsHost.ae = QString(getJsonString("pacs", "ae"));
    mPacsHost.ip = QString(getJsonString("pacs", "ip"));
    mPacsHost.localAE = QString(getJsonString("pacs", "localAE"));
    mPacsHost.port = QString(getJsonString("pacs", "port"));

    mLocalHost.ae = QString(getJsonString("address", "ae"));
    mLocalHost.ip = QString(getJsonString("address", "ip"));
    mLocalHost.localAE = QString(getJsonString("address", "localAE"));
    mLocalHost.port = QString(getJsonString("address", "port"));

    mReconHost.ae = QString(getJsonString("recon", "ae"));
    mReconHost.ip = QString(getJsonString("recon", "ip"));
    mReconHost.localAE = QString(getJsonString("recon", "localAE"));
    mReconHost.port = QString(getJsonString("recon", "port"));

    QString path = QString(getJsonString("recon", "transferPath"));
    mReconTransferPath = path.isEmpty() ? DEFAULT_RECON_TRANSFER_PATH : path;
    if(mReconTransferPath.back() == '/')
    {
        mReconTransferPath.chop(1);
    }
    mScanCanWithoutRecon = getBool("recon", "scancanwithoutrecon");

    mMppsHost.ae = QString(getJsonString("mpps", "ae"));
    mMppsHost.ip = QString(getJsonString("mpps", "ip"));
    mMppsHost.localAE = QString(getJsonString("mpps", "localAE"));
    mMppsHost.port = QString(getJsonString("mpps", "port"));
    mMppsOpen = getBool("mpps","open");

    mDefaultIpAddress.ip = QString(getJsonString("address", "ip"));
    mDefaultIpAddress.mask = QString(getJsonString("address", "mask"));
    mDefaultIpAddress.gateway = QString(getJsonString("address", "gateway"));
    mDefaultIpAddress.dhcp = getBool("address","dhcp");
}

void JsonObject::setJsonString(const char* catergory, const char* stringName, const char* stringValue, bool save)
{
	if (!loadcfg())
		return;

	cJSON* first = cJSON_GetObjectItem((cJSON*)json_root, catergory);
	if (!first) return;

	cJSON* Item = cJSON_CreateString(stringValue);
    cJSON* valItem = cJSON_GetObjectItem(first, stringName);
	if (valItem){
        cJSON_ReplaceItemInObject(first, stringName, Item);
    }
	else{
        cJSON_AddItemToObject(first, stringName , Item);
    }
	if (save)
	{
		savecfg();
	}
}

char* JsonObject::getJsonString(const char* catergory, const char* stringName)
{
	if (!loadcfg())
		return nullptr;

	cJSON* first = cJSON_GetObjectItem((cJSON*)json_root, catergory);
	if (!first) return nullptr;

	cJSON* second = cJSON_GetObjectItem(first, stringName);
	if (!second) return nullptr;
	return second->valuestring;

}

void JsonObject::setBool(const char *catergory, const char *stringName, bool val, bool save) {
    if (!loadcfg())
        return;

    cJSON* first = cJSON_GetObjectItem((cJSON*)json_root, catergory);
    if (!first) return;

    cJSON* Item = cJSON_CreateBool(val?1:0);
    cJSON* valItem = cJSON_GetObjectItem(first, stringName);
    if (valItem){
        cJSON_ReplaceItemInObject(first, stringName, Item);
    }
    else{
        cJSON_AddItemToObject(first, stringName , Item);
    }
    if (save)
    {
        savecfg();
    }
}

bool JsonObject::getBool(const char* catergory, const char* stringName)
{
    if (!loadcfg())
        return false;

    cJSON* first = cJSON_GetObjectItem((cJSON*)json_root, catergory);
    if (!first) return false;

    cJSON* second = cJSON_GetObjectItem(first, stringName);
    if (!second) return false;
    return second->valueint;
}

char* JsonObject::getArrayNode(const char* catergory, const char* stringName, int index, const char* id)
{
	if (!loadcfg())
		return nullptr;

	cJSON* first = cJSON_GetObjectItem((cJSON*)json_root, catergory);
	if (!first) return nullptr;

	cJSON* second = cJSON_GetObjectItem(first, stringName);
	if (!second) return nullptr;

	cJSON* third = cJSON_GetArrayItem(second, index);
	if (!third) return nullptr;
	cJSON* fourth = cJSON_GetObjectItem(third, id);

	if (!fourth) return nullptr;
	return fourth->valuestring;
}

void JsonObject::setArrayNode(const char* catergory, const char* stringName, int index, const char* id, const char* stringValue)
{
	if (!loadcfg())
		return;

	cJSON* first = cJSON_GetObjectItem((cJSON*)json_root, catergory);
	if (!first) return;

	cJSON* second = cJSON_GetObjectItem(first, stringName);
	if (!second) return;

	cJSON* third = cJSON_GetArrayItem(second, index);
	if (!third) return;
	cJSON* Item = cJSON_CreateString(stringValue);
	cJSON_ReplaceItemInObject(third, id, Item);
}


int JsonObject::getArraySize(const char* catergory, const char* stringName)
{
	if (!loadcfg())
		return 0;

	cJSON* first = cJSON_GetObjectItem((cJSON*)json_root, catergory);
	if (!first) return 0;

	cJSON* second = cJSON_GetObjectItem(first, stringName);
	if (!second) return 0;
	return cJSON_GetArraySize(second);
}


void JsonObject::setDefaultUser(const QString& str)
{
	setJsonString("login", "defaultUser", str.toStdString().c_str());
    mDefaultUser = str;
}
QString JsonObject::defaultUser()
{
    return mDefaultUser;

}
QStringList JsonObject::protocals()
{
    return mProtocalList;
}

int JsonObject::defaultProtocal()
{
    return mDefaultProtocal;
}

void JsonObject::setDefaultProtocal(int str)
{
    setJsonString("protocol", "default", QString::number(str).toStdString().c_str());
    mDefaultProtocal = str;
}

QStringList JsonObject::lockScreenTimes()
{
    return mLockScreenTimeList;
}

QString JsonObject::defaultFilter()
{
	char* str = getJsonString("worklistfilter", "default");
	return QString(str);
}

void JsonObject::setDefaultFilter(const QString& str)
{
	setJsonString("worklistfilter", "default", str.toStdString().c_str());
}

QStringList JsonObject::worklistFilters()
{
	if (!loadcfg())
		return QStringList();

	cJSON* first = cJSON_GetObjectItem((cJSON*)json_root, "worklistfilter");
	if (!first) return QStringList();

	cJSON* second = cJSON_GetObjectItem(first, "lists");


	std::string lans = second->valuestring;
	QString str = QString::fromLocal8Bit(QByteArray::fromRawData(lans.c_str(), lans.size()));
	return str.split(";");

}

QStringList JsonObject::languageList()
{
    return mLanguageList;
}

void JsonObject::setDefaultLanguage(const QString& str)
{
	setJsonString("general", "defaultlanguage", str.toStdString().c_str());
    mDefaultLanguage = str;
}

QString JsonObject::defaultLanguage()
{
    return mDefaultLanguage;
}

QString JsonObject::institutionName()
{
    return mInstitutionName;
}
void JsonObject::setInstitutionName(const QString& str)
{
	setJsonString("general", "institutionName", str.toStdString().c_str());
    mInstitutionName = str;
}

QString JsonObject::institutionAddr()
{
    return mInstitutionAddr;
}

void JsonObject::setInstitutionAddr(const QString& str)
{
	setJsonString("general", "institutionAddr", str.toStdString().c_str());
    mInstitutionAddr = str;
}

int JsonObject::getLockScreenTime()
{
    return mLockScreenTime;
}

void JsonObject::setLockScreenTime(int aTime)
{
     setJsonString("general", "lockscreen", QString::number(aTime).toStdString().c_str());
     mLockScreenTime = aTime;
}

QString JsonObject::storageAlarmSize()
{
    return mStorageAlarmSize;
}

bool JsonObject::loadcfg()
{
	if (m_bLoaded)
		return true;

	std::ifstream inFile(strProductFileName);
	if (!inFile.is_open())
	{
		return loadcfgDefault();
	}
	std::stringstream ss;
	ss << inFile.rdbuf();
	std::string strJsonData = ss.str();
	json_root = cJSON_Parse(strJsonData.c_str());
	inFile.close();


	if (!json_root)
		return loadcfgDefault();

	m_bLoaded = true;
	return true;
}


bool JsonObject::loadcfgDefault()
{

	std::ifstream inFile(strProductFileNameDefault);
	if (!inFile.is_open())
	{
		return false;
	}
	std::stringstream ss;
	ss << inFile.rdbuf();
	std::string strJsonData = ss.str();
	json_root = cJSON_Parse(strJsonData.c_str());
	inFile.close();

	if (!json_root)
		return false;

	m_bLoaded = true;
	return true;
}

bool JsonObject::savecfg()
{
	if (!m_bLoaded)
		return false;

	std::ofstream outFile(strProductFileName);
	if (!outFile.is_open())
	{
		return false;
	}

	char* strJsonData = cJSON_Print((cJSON*)json_root);
	std::stringstream ss;
	ss << strJsonData;
	outFile << ss.rdbuf();
	outFile.close();
	m_bLoaded = false;
	return true;
}

host JsonObject::getServer(ServerType type)
{
	QString typeName;
	switch (type)
	{

	case JsonObject::WORKLIST:
        return mWorklistHost;
	case JsonObject::PACS:
        return mPacsHost;
	case JsonObject::LOCAL:
        return mLocalHost;
	case JsonObject::RECON:
        return mReconHost;
    case JsonObject::MPPS:
        return mMppsHost;
	}
}

void JsonObject::setServer(ServerType type, const host& list)
{
	QString typeName;
	switch (type)
	{

	case JsonObject::WORKLIST:
        typeName = "worklist";
        mWorklistHost = list;
        break;
	case JsonObject::PACS:
		typeName = "pacs";
        mPacsHost = list;
		break;
	case JsonObject::LOCAL:
		typeName = "address";
        mLocalHost = list;
		break;
	case JsonObject::RECON:
		typeName = "recon";
        mReconHost = list;
		break;
    case JsonObject::MPPS:
        typeName = "mpps";
        mMppsHost = list;
        break;
	}
	setJsonString(typeName.toStdString().c_str(), "ae", list.ae.toStdString().c_str(), false);
	setJsonString(typeName.toStdString().c_str(), "ip", list.ip.toStdString().c_str(), false);
	setJsonString(typeName.toStdString().c_str(), "localAE", list.localAE.toStdString().c_str(), false);
	setJsonString(typeName.toStdString().c_str(), "port", list.port.toStdString().c_str(), false);

	savecfg();
}


QString JsonObject::interfaceName()
{
    return mInterfaceName;
}

QString JsonObject::passWord()
{
	return tmp_psw;
}

void JsonObject::setPassword(const QString& pwd)
{
	tmp_psw = pwd;
}
void JsonObject::setInterfaceName(const QString& name)
{
	setJsonString("address", "device", name.toStdString().c_str());
    mInterfaceName = name;
}

bool JsonObject::isDHCP()
{
    return mDefaultIpAddress.dhcp;
}

void JsonObject::autoDHCP(bool ena)
{
    setBool("address","Dhcp", ena, true);
    mDefaultIpAddress.dhcp = ena;
}

IpAddr JsonObject::getDefaultIpAddr()
{
    return mDefaultIpAddress;
}

void JsonObject::setDefaultIpAddr(const IpAddr& addr)
{
	setJsonString("address", "ip", addr.ip.toStdString().c_str());
	setJsonString("address", "mask", addr.mask.toStdString().c_str());
    setJsonString("address", "gateway", addr.gateway.toStdString().c_str());
    setBool("address","dhcp", addr.dhcp, true);
    mDefaultIpAddress = addr;
}

QList<QStringList> JsonObject::getIpAddrList()
{

	QList<QStringList> obj;
	int size = getArraySize("address", "additional");
	for (int i = 0; i < size; i++)
	{
		QStringList temp;
		char* ip_str = getArrayNode("address", "additional", i, "ip");
		char* mask_str = getArrayNode("address", "additional", i, "netmask");

		temp << ip_str << mask_str;
		obj.push_back(temp);
	}
	return obj;
}

void JsonObject::setIpAddrList(const QList<QStringList>& list)
{
	for (int i = 0; i < list.size(); i++) {
		setArrayNode("address", "additional", i, "ip", list.at(i)[0].toStdString().c_str());
		setArrayNode("address", "additional", i, "netmask", list.at(i)[1].toStdString().c_str());
	}
	savecfg();
}

QString JsonObject::getDefaultGateway()
{
    return mGateway;
}

void JsonObject::setDefaultGateway(const QString& gw)
{
	setJsonString("routing", "defaultgateway", gw.toStdString().c_str());
    mGateway = gw;
}

QList<QStringList> JsonObject::getIpRouteList()
{
	QList<QStringList> obj;
	int size = getArraySize("routing", "routingtable");
	for (int i = 0; i < size; i++)
	{
		QStringList temp;
		char* des_str = getArrayNode("routing", "routingtable", i, "destination");
		char* gw_str = getArrayNode("routing", "routingtable", i, "gateway");
		char* nm_str = getArrayNode("routing", "routingtable", i, "netmask");

		temp << des_str << nm_str << gw_str;
		obj.push_back(temp);
	}
	return obj;
}

void JsonObject::setIpRouteList(const QList<QStringList>& list)
{
	for (int i = 0; i < list.size(); i++) {
		setArrayNode("routing", "routingtable", i, "destination", list.at(i)[0].toStdString().c_str());
		setArrayNode("routing", "routingtable", i, "netmask", list.at(i)[1].toStdString().c_str());
		setArrayNode("routing", "routingtable", i, "gateway", list.at(i)[2].toStdString().c_str());
	}
	savecfg();
}

void JsonObject::setEmptyScanID(const char *id) {
    setJsonString("deviceparam","EmptyScanID",id, true);
}

const char *JsonObject::getEmptyScanID() {
    return getJsonString("deviceparam","EmptyScanID");
}

bool JsonObject::getScanConfirm() {
    return mScanConfirm;
}

void JsonObject::setScanConfirm(bool val) {
    setBool("general","ScanConfirm", val, true);
    mScanConfirm = val;
}

bool JsonObject::getCompleteNotify() {
    return mCompleteNotify;
}

void JsonObject::setCompleteNotify(bool val) {
    setBool("general","CompleteNotify", val, true);
    mCompleteNotify = val;
}

bool JsonObject::getAnonymousMode()
{
    return mAnonymousMode;
}

void JsonObject::setAnonymousMode(bool val)
{
    setBool("general","AnonymousMode", val, true);
    mAnonymousMode = val;
}

bool JsonObject::getScreenSaverMode()
{
    return mScreenSaverMode;
}

void JsonObject::setScreenSaverMode(bool aIsOpen)
{
    setBool("screensaver","open", aIsOpen, true);
    mScreenSaverMode = aIsOpen;
}

QStringList JsonObject::getScreenSaverInfomation()
{
    return mScreenSaverInfoList;
}

bool JsonObject::isDmsSimulator()
{
    return mDmsSimulator;
}

int JsonObject::getOperationLogExpireDays()
{
    return mOperationLogExpireDays;
}

int JsonObject::getPatientListExpireDays()
{
    return mPatientListExpireDays;
}

int JsonObject::getScanListExpireDays()
{
    return mScanListExpireDays;
}

bool JsonObject::getMppsOpen()
{
    return mMppsOpen;
}

void JsonObject::setMppsOpen(bool aIsOpen)
{
    mMppsOpen = aIsOpen;
    setBool("mpps","open", aIsOpen, true);
}

QString JsonObject::getReconTransferPath()
{
    return mReconTransferPath;
}

bool JsonObject::getScanCanWithoutRecon()
{
    return mScanCanWithoutRecon;
}

QString JsonObject::getWorklistFilterModality()
{
    return mWorklistFilterModality;
}

void JsonObject::setWorklistFilterModality(const QString& aModality)
{
    mWorklistFilterModality = aModality;
    setJsonString("worklistfilter","modality", aModality.toStdString().c_str());
}

QString JsonObject::getWorklistFilterDate()
{
    return mWorklistFilterDays;
}

void JsonObject::setWorklistFilterDate(const QString& aDate)
{
    mWorklistFilterDays = aDate;
    setJsonString("worklistfilter","date", aDate.toStdString().c_str());
}