DPS/DataPlatform/DataPackEventModule.cpp

#pragma execution_character_set("utf-8")

#include <QFileDialog>
#include <QCoreApplication>
#include <QProcess>
#include "DataPackEventModule.h"
#include "DataManager.h"
#include "DataModelData.h"
#include "DataPack.h"
#include "DataClass.h"
#include "DataAttribute.h"
#include "global.h"
#include "DataAccessModule.h"
#include "TransformExcel.h"
#include "global.h"
#include "SceneInfo.h"
#include "common.h"
#include "QWaiting.h"
#include "Session.h"
#include "mainwindow.h"

DataPackEventModule::DataPackEventModule(QObject* /*parent*/, DataManager* manager)
	:BaseEventModule(manager, "DataModelGraphView")
{
	addShareEventModule(new DataAccessModule(pDataManager));
}

DataPackEventModule::~DataPackEventModule()
{

}

bool DataPackEventModule::onMessage(const std::string& eventName, json& parameter)
{
	LOG(INFO) << CommonHelper::utf8ToStdString("DataPackEventModule receive message.......");
	LOG(INFO) << eventName;
	LOG(INFO) << CommonHelper::jsonToString(parameter);
	TRY{
		if (eventName == "add-datamodule-child")
		{
			//批量移入移出数据模块、数据类
			return moveDataPackOrClass(parameter);
		}
		else if (eventName == "create-relationship")
		{
			//建立数据关系
			return buildDataRelationship(parameter);
		}
		else if (eventName == "delete-relationship")
		{
			//删除数据关系
			return deleteDataRelationship(parameter);
		}
		else if (eventName == "add-datamodule")
		{
			//新建数据类模块
			return addDataPack(parameter);
		}
		else if (eventName == "delete-datamodule")
		{
			//删除数据类模块
			return deleteDataPack(parameter);
		}
		else if (eventName == "save-datamodule")
		{
			//编辑数据类模块
			return updateDataPack(parameter);
		}
		if (eventName == "add-dataclass")
		{
			//新建数据类
			return addDataClass(parameter);
		}
		else if (eventName == "delete-dataclass")
		{
			//删除数据类
			return deleteDataClass(parameter);
		}
		else if (eventName == "save-dataclass")
		{
			//修改数据类
			return updateDataClass(parameter);
		}
		else if (eventName == "add-dataclass-attribute")
		{
			//新建数据属性-复制属性
			return addDataClassAttribute(parameter);
		}
		else if (eventName == "delete-classattribute")
		{
			//删除数据属性
			return deleteDataClassAttribute(parameter);
		}
		else if (eventName == "save-dataclass-attribute")
		{
			//修改数据属性
			return updateDataClassAttribute(parameter);
		}  //以下为数据字典相关消息事件 
		else if (eventName == "get-datadictionary-data")
		{
			//数据字典显示，返回实例数据
			return getDictionaryData(parameter);
		}
		else if (eventName == "import-datadictionary")
		{
			//导入数据字典类
			return importDictionary(parameter);
		}
		else if (eventName == "export-template")
		{
			//生成导入表模板
			return exportTemplate(parameter);
		}
		else if (eventName == "export-datadictionary")
		{
			//导出数据字典类
			return exportDictionary(parameter);
		}
		else if (eventName == "import-datamodel")
		{
			//数据模型导入
			return importDataModel(parameter);
		}
		else if (eventName == "export-datamodel")
		{
			//数据模型导出
			return exportDataModel(parameter);
		}
		else if (eventName == "add-scenenode")
		{
			//增加场景
			return addSceneNode(parameter);
		}
		else if (eventName == "get-datamodel-scene")
		{
			//获取场景数据
			return getSceneNode(parameter);
		}
		else if (eventName == "delete-scenenode")
		{
			//删除场景
			return deleteScene(parameter);
		}
		else if (eventName == "move-scense-node")
		{
			return updateScene(parameter);
		}
	}
	CATCH(parameter);


	return EventModule::onMessage(eventName, parameter);
}


//以下：消息事件具体执行函数

bool DataPackEventModule::moveDataPackOrClass(json& parameter)
{
	auto data = parameter["data"];
	int dataId = data["id"];//数据模块或数据类id
//	int newPackId = data["parentid"];//新的数据模块id
	int classType = data["classType"];
	if (classType == g_TYPE_DATAPACK)
	{
		//数据模块
		DPData* pData = pDataManager->findObjectById(DataManager::DataType::dataPack, dataId);
		DataPack* pPack = qobject_cast<DataPack*>(pData);
		if (pPack && pPack->moveData(parameter, pDataManager))
		{
			// 			id	数据模块或数据类ID
			// 				classType	模块类型：1为模块，2为数据类
			// 				parentid	新的数据模块ID
			// 				oldparentid	原有的数据模块ID

						//移出移入成功
			data["id"] = dataId;
			data["classType"] = g_TYPE_DATAPACK;
			data["parentid"] = data["parentid"];
			data["oldparentid"] = pData->_parent->_id;
			parameter["response"] = data;
		}
		else
		{
			//移出移入失败
			parameter["error"] = "移入移出操作失败";
		}
	}
	else if (classType == g_TYPE_DATACLASS)
	{
		//数据类
		DPData* pData = pDataManager->findObjectById(DataManager::DataType::dataClass, dataId);
		DataClass* pClass = qobject_cast<DataClass*>(pData);
		if (pData && pClass->moveData(parameter, pDataManager))
		{
			//成功
			data["id"] = dataId;
			data["classType"] = g_TYPE_DATACLASS;
			data["parentid"] = data["parentid"];
			data["oldparentid"] = pData->_parent->_id;
			parameter["response"] = data;
		}
		else
		{
			//失败
			//移出移入失败
			parameter["error"] = "移入移出操作失败";
		}
	}

	LOG(INFO) << CommonHelper::utf8ToStdString("moveDataPackOrClass Sendto web.......");
	LOG(INFO) << CommonHelper::jsonToString(parameter);
	return true;
}

//增加数据模块
bool DataPackEventModule::addDataPack(json& parameter)
{
	auto data = parameter["data"];
	int parentId = data["parentid"]; //上层id
	int classType = data["classType"];
	DataPack* pNewPack = new DataPack();
	pNewPack->setNewData(parameter);
	//名称合法性判断
	QString msg;
	if ( pNewPack->checkNameillegal(msg))
	{
		delete pNewPack;
		pNewPack = nullptr;
		parameter["error"] = CommonHelper::qstringToUtf8(msg);
	}
	else 
	{
		DPData* pParent = nullptr;
		if (classType == g_TYPE_DATAMODEL)
		{
			//在数据模型下直接建
			pParent = pDataManager->findObjectById(DataManager::DataType::dataModel, parentId);
		}
		else if (classType == g_TYPE_DATAPACK)
		{
			//在数据模块下建子模块
			pParent = pDataManager->findObjectById(DataManager::DataType::dataPack, parentId);
			//设置子模块信息
			pNewPack->_bIsChildPack = true;
		}
		if (pParent) 
		{

			pNewPack->_parent = pParent; //设置上层对象 
			if (pParent->addChild(pNewPack))
			{
				//添加到map
				pDataManager->insertDataMap(DataManager::DataType::dataPack, pNewPack->_id, pNewPack);
				json j;
				pNewPack->toJson(j);
				parameter["response"] = j;
			}
			else
			{
				delete pNewPack;
				pNewPack = nullptr;
				parameter["error"] = "新建模块失败";
			}
		}
		else {
			delete pNewPack;
			pNewPack = nullptr;
			parameter["error"] = "查找模块父类失败";
		}

	}

	
	LOG(INFO) << CommonHelper::utf8ToStdString("addDataPack Sendto web.......");
	LOG(INFO) << CommonHelper::jsonToString(parameter);
	return true;

}

bool DataPackEventModule::deleteDataPack(json& parameter)
{
	//获得id
	auto data = parameter["data"];
	auto dataPackId = data["id"];
	QString result;
	DataPack* pData = qobject_cast<DataPack*>(pDataManager->findObjectById(DataManager::DataType::dataPack, dataPackId));
	if (pData && pData->deleteSelf(result))
	{
		//更新总map
		pDataManager->deleteInDataMap(DataManager::DataType::dataPack, dataPackId);
		delete pData;
		pData = nullptr;
		//删除成功，返回

// 		parameter["response"] = json::array();
// 
// 		if (!result.isEmpty())
// 		{
// 			QStringList typeIdlist = result.split("#");
// 			for (int i = 0; i < typeIdlist.size(); i++)
// 			{
// 				QString typeId = typeIdlist.at(i);
// 				int pos = typeId.indexOf(",");
// 				int type = typeId.left(pos).toInt();
// 				int id = typeId.right(typeId.size() - 1 - pos).toInt();
// 				json j;
// 				j["id"] = id;
// 				j["classType"] = type;
// 				parameter["response"].push_back(j);
// 			}
// 		}
		parameter["response"]["status"] = true;

	}
	else
	{
		//如保提示删除模块失败？
		parameter["response"]["status"] = false;

	}
	LOG(INFO) << CommonHelper::utf8ToStdString("deleteDataPack Sendto web.......");
	LOG(INFO) << CommonHelper::jsonToString(parameter);
	return true;
}

bool DataPackEventModule::updateDataPack(json& parameter)
{
	//修改name type desciption 是否生成数据表
	auto data = parameter["data"];
	auto dataPackId = data["id"];
	//查找当前数据类模块
	DPData* pDataPack = pDataManager->findObjectById(DataManager::DataType::dataPack, dataPackId);
	if (pDataPack) {
		pDataPack->setNewData(parameter);
		if (pDataPack->saveSelf())
		{
			//更新数据成功，返回给web端
			json j;
			pDataPack->toJson(j);
			parameter["response"] = j;

		}
		else
		{
			parameter["error"] = "修改模块失败";

		}
	}
	else {
		parameter["error"] = "查找模块失败";
	}
	LOG(INFO) << CommonHelper::utf8ToStdString("deleteDataPack Sendto web.......");
	LOG(INFO) << CommonHelper::jsonToString(parameter);
	return true;
}

//数据类
bool DataPackEventModule::getDataClass(json& parameter)
{
	auto data = parameter["data"];
	int id = data["id"];
	DPData* pData = pDataManager->findObjectById(DataManager::DataType::dataClass, id);
	if (pData)
	{
		json j;
		pData->toJson(j);
		parameter["response"] = j;
	}
	else
	{
		parameter["error"] = "该数据类不存在";
	}
	LOG(INFO) << CommonHelper::utf8ToStdString("getDataClass Sendto web.......");
	LOG(INFO) << CommonHelper::jsonToString(parameter);
	return true;
}


bool DataPackEventModule::addDataClass(json& parameter)
{
	const int COMMON_CLASS = 1;
	DataClass* pNewDataClass = new DataClass();
	auto data = parameter["data"];
	auto parentId = data["parentid"]; //上层id
	pNewDataClass->setNewData(parameter);
	pNewDataClass->reName();

	QString errMsg;
	//判断名称标识合法性
	if (!pNewDataClass->checkNameSize(3, 128, errMsg) || !pNewDataClass->checkLetter(errMsg,2))
	{
		delete pNewDataClass;
		pNewDataClass = nullptr;
		parameter["error"] = CommonHelper::qstringToUtf8(errMsg);
	}
	else
	{
		pNewDataClass->_type = COMMON_CLASS;//普通数据类
	//查找当前父模块
		DPData* pData = pDataManager->findObjectById(DataManager::DataType::dataPack, parentId);
		pNewDataClass->_parent = pData; //设置上层对象 
		if (pData && pData->addChild(pNewDataClass))
		{
			//添加到总map
			pDataManager->insertDataMap(DataManager::DataType::dataClass, pNewDataClass->_id, pNewDataClass);
			json j;
			pNewDataClass->toJson(j);
			parameter["response"] = j;
		}
		else
		{
			delete pNewDataClass;
			pNewDataClass = nullptr;
			parameter["error"] = "新建数据类失败";
		}
	}


	LOG(INFO) << CommonHelper::utf8ToStdString("addDataClass Sendto web.......");
	LOG(INFO) << CommonHelper::jsonToString(parameter);
	return true;

}

bool DataPackEventModule::deleteDataClass(json& parameter)
{
	//获得id
	auto data = parameter["data"];
	int  dataClassID = data["id"];
	QString result;
	DataClass* pClass = qobject_cast<DataClass*>(pDataManager->findObjectById(DataManager::DataType::dataClass, dataClassID));
	if (!pClass)
	{
		parameter["error"] = "数据类不存在";
		LOG(INFO) << CommonHelper::utf8ToStdString("deleteDataClass Sendto web.......");
		LOG(INFO) << CommonHelper::jsonToString(parameter);
		return true;
	}
	if (pClass->deleteFromModel(result))
	{
		delete pClass;
		pClass = nullptr;
		parameter["response"] = json::array();

		if (!result.isEmpty())
		{
			QStringList typeIdlist = result.split("#");
			for (int i = 0; i < typeIdlist.size(); i++)
			{
				QString typeId = typeIdlist.at(i);
				int pos = typeId.indexOf(",");
				int type = typeId.left(pos).toInt();
				int id = typeId.right(typeId.size() - 1 - pos).toInt();
				json j;
				j["id"] = id;
				j["classType"] = type;
				parameter["response"].push_back(j);
			}
		}
	}
	else
	{
		parameter["response"]["status"] = false;
	}
	LOG(INFO) << CommonHelper::utf8ToStdString("deleteDataClass Sendto web.......");
	LOG(INFO) << CommonHelper::jsonToString(parameter);
	return true;
}

bool DataPackEventModule::updateDataClass(json& parameter)
{
	auto data = parameter["data"];
	auto dataClassId = data["id"];
	//查找当前数据类
	DPData* pDataClass = pDataManager->findObjectById(DataManager::DataType::dataClass, dataClassId);
	if (pDataClass) {
		pDataClass->setNewData(parameter);
		if (pDataClass->saveSelf())
		{
			//更新数据成功，返回给web端
			parameter["response"] = data;
		}
		else
		{
			//失败
			parameter["error"] = "修改数据类失败";
		}
	}
	else {
		parameter["error"] = "查询数据类失败";
	}
	LOG(INFO) << CommonHelper::utf8ToStdString("updateDataClass Sendto web.......");
	LOG(INFO) << CommonHelper::jsonToString(parameter);
	return true;
}

//建立数据关关联
bool DataPackEventModule::buildDataRelationship(json& parameter)
{
	bool status = false;
	auto data = parameter["data"];
	int type = data["type"];//关系类型
	int mainClassId = data["id1"]; //主数据类
	int subClassId = data["id2"]; // 关联数据类
	DataClass* pNewRelationClass;
	QString nameFlag1 = CommonHelper::utf8ToQString(data["crname1"]);
	QString nameFlag2 = CommonHelper::utf8ToQString(data["crname2"]);
	DPData* pClass1 = pDataManager->findObjectById(DataManager::DataType::dataClass, mainClassId);
	DPData* pClass2 = pDataManager->findObjectById(DataManager::DataType::dataClass, subClassId);
	status = DataClass::buildRelationship(pClass1, pClass2, nameFlag1, nameFlag2, type, pNewRelationClass);

	if (type == RELATION_MN)
	{
		json j;
		pNewRelationClass->toJson(j, true);
		parameter["response"] = j;
	}
	else
	{
		if (status == true)
		{
			parameter["response"]["status"] = status;
		}
		else
		{
			parameter["error"] = "建立数据关系失败";
		}
	}

	LOG(INFO) << CommonHelper::utf8ToStdString("buildDataRelationship Sendto web.......");
	LOG(INFO) << CommonHelper::jsonToString(parameter);
	return true;

}

bool DataPackEventModule::deleteDataRelationship(json& parameter)
{
	auto data = parameter["data"];
	int classId1 = data["id1"];
	int classId2 = data["id2"];
	QString result;
	DPData* pClass1 = pDataManager->findObjectById(DataManager::DataType::dataClass, classId1);
	DPData* pClass2 = pDataManager->findObjectById(DataManager::DataType::dataClass, classId2);
	bool status = DataClass::deleteRelationship(pClass1, pClass2, result);

	parameter["response"] = json::array();

	if (!result.isEmpty())
	{
		QStringList typeIdlist = result.split("#");
		for (int i = 0; i < typeIdlist.size(); i++)
		{
			QString typeId = typeIdlist.at(i);
			int pos = typeId.indexOf(",");
			int type = typeId.left(pos).toInt();
			int id = typeId.right(typeId.size() - 1 - pos).toInt();
			json j;
			j["id"] = id;
			j["classType"] = type;
			parameter["response"].push_back(j);
		}
	}

	LOG(INFO) << CommonHelper::utf8ToStdString("deleteDataRelationship Sendto web.......");
	LOG(INFO) << CommonHelper::jsonToString(parameter);
	return true;
}

//属性
bool DataPackEventModule::addDataClassAttribute(json& parameter)
{

	auto data = parameter["data"];
	int parentId = data["parentid"]; //上层id
	//先判断输入属性名称标识是否合理
	QString name = CommonHelper::utf8ToQString(data["name"]);
	QString errMsg;

	DataAttribute* pNewDataAttribute = new DataAttribute();
	pNewDataAttribute->setNewData(parameter);

	pNewDataAttribute->reName();
	if ( !pNewDataAttribute->checkNameSize(2,128,errMsg) || !pNewDataAttribute->checkLetter(errMsg,1) || pNewDataAttribute->illegalName(errMsg))
	{
		//名称标识不合法
		parameter["error"] = CommonHelper::qstringToUtf8(errMsg);
		delete pNewDataAttribute;
		pNewDataAttribute = nullptr;
	}
	else
	{
		//查找当前父模块
		DPData* pData = pDataManager->findObjectById(DataManager::DataType::dataClass, parentId);
		pNewDataAttribute->_parent = pData; //设置上层对象 
		if (pData && pData->addChild(pNewDataAttribute))
		{
			//添加到总map
			pDataManager->insertDataMap(DataManager::DataType::dataAttribute, pNewDataAttribute->_id, pNewDataAttribute);
			json j;
			pNewDataAttribute->toJson(j);
			parameter["response"] = j;
		}
		else
		{
			delete pNewDataAttribute;
			pNewDataAttribute = nullptr;
			parameter["error"] = "新建数据类属性失败";
		}
	}


	LOG(INFO) << CommonHelper::utf8ToStdString("addDataClassAttribute Sendto web.......");
	LOG(INFO) << CommonHelper::jsonToString(parameter);
	return true;
}

bool DataPackEventModule::deleteDataClassAttribute(json& parameter)
{
	//获得id
	auto data = parameter["data"];
	auto dataAttributeID = data["id"];

	DPData* pDataClassAttribute = pDataManager->findObjectById(DataManager::DataType::dataAttribute, dataAttributeID);
	if (pDataClassAttribute && pDataClassAttribute->deleteSelf())
	{
		//删除成功
		delete pDataClassAttribute;
		pDataClassAttribute = nullptr;
		//删除成功
		parameter["response"]["status"] = true;
	}
	else
	{
		//失败
		parameter["response"]["status"] = false;
	}

	LOG(INFO) << CommonHelper::utf8ToStdString("deleteDataClassAttribute Sendto web.......");
	LOG(INFO) << CommonHelper::jsonToString(parameter);
	return true;
}

bool DataPackEventModule::updateDataClassAttribute(json& parameter)
{
	auto data = parameter["data"];
	auto dataAttributeId = data["id"];
	//查找当前数据类属性
	DPData* pDataAttribute = pDataManager->findObjectById(DataManager::DataType::dataAttribute, dataAttributeId);
	if (pDataAttribute) {
		pDataAttribute->setNewData(parameter);
		if (pDataAttribute->saveSelf())
		{
			//更新数据成功，返回给web端
			parameter["response"] = data;

		}
		else
		{
			//失败
			parameter["response"]["status"] = false;
		}
	}
	else {
		parameter["error"] = "查询数据类失败";
	}

	LOG(INFO) << CommonHelper::utf8ToStdString("updateDataClassAttribute Sendto web.......");
	LOG(INFO) << CommonHelper::jsonToString(parameter);
	return true;
}


bool DataPackEventModule::importDictionary(json& parameter)
{
	auto data = parameter["data"];
	int id = data["id"];
	//查找数据类
	DataClass* pDataClass = qobject_cast<DataClass*>(pDataManager->findObjectById(DataManager::DataType::dataClass, id));
	QString ret;
	if (pDataClass)
	{
		if (pDataClass->importDict(ret))
		{
			parameter["response"]["status"] = true;
		}
		else
		{
			parameter["error"] = CommonHelper::qstringToUtf8(ret);
		}
	}
	else
	{
		parameter["error"] = "查询数据类失败";
	}

	LOG(INFO) << CommonHelper::utf8ToStdString("importDictionary Sendto web.......");
	LOG(INFO) << CommonHelper::jsonToString(parameter);
	return true;
}

bool DataPackEventModule::exportTemplate(json& parameter)
{
	auto data = parameter["data"];
	int id = data["id"];
	//查找数据类
	DataClass* pDataClass = qobject_cast<DataClass*>(pDataManager->findObjectById(DataManager::DataType::dataClass, id));
	
	try
	{
		if (!pDataClass)
			throw exception("查询数据类失败");
		int ret = pDataClass->exportTemplate();
		if (ret == 0)
		{
			parameter["response"]["status"] = true;
		}
		else if (ret == 1)
		{
			parameter["response"]["status"] = false;
		}
	}
	catch (exception& e)
	{
		parameter["error"] = e.what();
		LOG(ERROR) << e.what();
	}
	LOG(INFO) << CommonHelper::utf8ToStdString("exportTemplate Sendto web.......");
	LOG(INFO) << CommonHelper::jsonToString(parameter);
	return true;
}

bool DataPackEventModule::exportDictionary(json& parameter)
{
	auto data = parameter["data"];
	int id = data["id"];
	//查找数据类
	DataClass* pDataClass = qobject_cast<DataClass*>(pDataManager->findObjectById(DataManager::DataType::dataClass, id));
	try
	{
		if (!pDataClass)
			throw exception("查询数据类失败");

		parameter["response"]["status"] = pDataClass->exportDict();
	}
	catch (exception& e)
	{
		LOG(ERROR) << e.what();
	}

	LOG(INFO) << CommonHelper::utf8ToStdString("exportDictionary Sendto web.......");
	LOG(INFO) << CommonHelper::jsonToString(parameter);
	return true;
}

bool DataPackEventModule::getDictionaryData(json& parameter)
{
	auto data = parameter["data"];
	int id = data["id"];
	//查找数据类

	DataClass* pDataClass = qobject_cast<DataClass*>(pDataManager->findObjectById(DataManager::DataType::dataClass, id));
	if (pDataClass) {
		json j;
		pDataClass->dictToJson(j);
		parameter["response"] = j;
	}
	else {
		parameter["error"] = "查询数据类失败";
	}

	//获取数据字典类的信息
	LOG(INFO) << CommonHelper::utf8ToStdString("getDictionaryData Sendto web.......");
	LOG(INFO) << CommonHelper::jsonToString(parameter);
	return true;
}

/*导入数据模型*/
bool DataPackEventModule::importDataModel(json& parameter)
{

	auto data = parameter["data"];
	int dataModelId = data["id"];
	TransformExcel transform(pDataManager, dataModelId);
	// 	DataModelData* pModel = qobject_cast<DataModelData*>(pDataManager->findObjectById(DataManager::DataType::dataModel, dataModelId));
	// 	int curProjectId = pModel->_parent->_id; //当前项目id
	QString curPath = QCoreApplication::applicationDirPath();
	QString selectDir = QFileDialog::getOpenFileName(nullptr, "选择导入文件", "", "*.xlsx");
	QString errMsg;
	if (!selectDir.isEmpty())
	{
		try
		{
			transform.openFile(selectDir);
			QWaiting waiting(Session::getSession()->parent(), "模型导入中...");

			if (waiting.working(std::bind(&TransformExcel::importData, &transform, std::ref(errMsg))))
			{
				parameter["response"]["status"] = true;
			}
			else
			{
				if (errMsg == "数据回滚失败，重启程序")
				{
				//	CommonHelper::message(errMsg,2);
					qApp->quit();
					QProcess::startDetached(qApp->applicationFilePath());
				}
				else if( errMsg == "模型导入失败") {
					//重新获取一次数据模型数据
					DataModelData* pModel = qobject_cast<DataModelData*>(pDataManager->findObjectById(DataManager::DataType::dataModel, dataModelId));
					if (pModel) {
						pModel->getAllChildren(pDataManager, true);
						pModel->_initChildren = true;
					}
				}

				parameter["error"] = CommonHelper::qstringToUtf8(errMsg);
			}
		}
		catch (exception& e)
		{
			LOG(ERROR) << e.what();
			LOG(ERROR) << CommonHelper::utf8ToStdString("DataPackEventModule::importDataModel catch exception");
		}

	}

	LOG(INFO) << CommonHelper::utf8ToStdString("importDataModel Sendto web.......");
	LOG(INFO) << CommonHelper::jsonToString(parameter);
	return true;
}
/*导出数据模型*/
bool DataPackEventModule::exportDataModel(json& parameter)
{
	TransformExcel transform(pDataManager, 0);

	QString file = QFileDialog::getSaveFileName(nullptr, tr("保存导出文件"), "", tr("*.xlsx"));

	if (!file.isEmpty())
	{		
		QFileInfo exportFile(file);
		if (exportFile.isFile())
		{
			if (!transform.openFile(file))
			{
				//如打开文件失败,直接返回
				parameter["error"] = "打开文件失败";
				LOG(INFO) << CommonHelper::utf8ToStdString("exportDataModel Sendto web.......");
				LOG(INFO) << CommonHelper::jsonToString(parameter);
				return true;
			}
		}

		QWaiting waiting(Session::getSession()->parent(), "模型导出中...");
		if (waiting.working(std::bind(&TransformExcel::exportData, &transform, std::ref(parameter))))
		{
			parameter["response"]["status"] = true;
		}
		else
		{
			parameter["error"] = "导出数据模型失败";
		}
		transform.closeFile(file);
	}

	LOG(INFO) << CommonHelper::utf8ToStdString("exportDataModel Sendto web.......");
	LOG(INFO) << CommonHelper::jsonToString(parameter);
	return true;
}

/*增加场景*/
bool DataPackEventModule::addSceneNode(json& parameter)
{
	auto data = parameter["data"];
	int parentType = data["parentClassType"]; //父类型
	int parentId = data["parentid"];    //父id
	SceneInfo* pNewScene = new SceneInfo;

	pNewScene->setNewData(parameter);
	DPData* pdata = nullptr;
	//查找要在哪个数据模块（类）下添加
	if (parentType == g_TYPE_DATACLASS)
	{
		pdata = pDataManager->findObjectById(DataManager::DataType::dataClass, parentId);
	}
	else if (parentType == g_TYPE_DATAPACK)
	{
		pdata = pDataManager->findObjectById(DataManager::DataType::dataPack, parentId);
	}
	if (!pdata)
	{
		delete pNewScene;
		pNewScene = nullptr;
		parameter["error"] = "父数据模块（数据类）查找失败";
		LOG(INFO) << CommonHelper::utf8ToStdString("addSceneNode Sendto web.......");
		LOG(INFO) << CommonHelper::jsonToString(parameter);
		return true;
	}
	if (pdata->addScene(pNewScene))
	{
		pNewScene->_parent = pdata;
		pDataManager->insertDataMap(DataManager::DataType::scene, pNewScene->_id, pNewScene);
		//添加场景成功
		json j;
		pNewScene->toJson(j);
		parameter["response"] = j;
	}
	else
	{
		//添加场景失败
		delete pNewScene;
		pNewScene = nullptr;
		parameter["response"] = { {"status",false} };
	}

	LOG(INFO) << CommonHelper::utf8ToStdString("addSceneNode Sendto web.......");
	LOG(INFO) << CommonHelper::jsonToString(parameter);
	return true;
}

/*删除场景*/
bool DataPackEventModule::deleteScene(json& parameter)
{
	auto data = parameter["data"];
	int id = data["id"];

	SceneInfo* pScene = qobject_cast<SceneInfo*>(pDataManager->findObjectById(DataManager::DataType::scene, id));
	if (pScene)
	{
		if (pScene->deleteSelf())
		{
			//所属于模块或类的场景map中删除
			DPData* pParent = pScene->_parent;
			pParent->deleteScene(id);
			pDataManager->deleteInDataMap(DataManager::DataType::scene, id);
			delete pScene;
			pScene = nullptr;

			parameter["response"] = { {"status",true} };
		}
		else
		{
			//删除失败
			parameter["response"] = { {"status",false} };
		}
	}
	else
	{
		LOG(INFO) << CommonHelper::utf8ToStdString("serch sceneInfo in scenemap failed");
	}

	LOG(INFO) << CommonHelper::utf8ToStdString("deleteScene Sendto web.......");
	LOG(INFO) << CommonHelper::jsonToString(parameter);
	return true;
}

bool DataPackEventModule::getSceneNode(json& parameter)
{
	auto data = parameter["data"];
	int modelid = data["modelid"];//数据模块或数据类id
	int classType = data["modelClassType"];
	QMap<int, SceneInfo*>::iterator it;
	parameter["response"] = json::array();
	if (classType == g_TYPE_DATACLASS)
	{
		DataClass* pClass = qobject_cast<DataClass*>(pDataManager->findObjectById(DataManager::DataType::dataClass, modelid));
		if (pClass)
		{
			if (!pClass->_initScene)
			{
				if (pClass->getScene(pDataManager))
				{
					//		pClass->_initScene = true;
				}
				else
				{
					parameter["error"] = "获取场景失败";
				}
			}

			for (it = pClass->_sceneMap.begin(); it != pClass->_sceneMap.end(); ++it)
			{
				json j;
				(*it)->toJson(j);
				parameter["response"].push_back(j);
			}
		}
	}
	else if (classType = g_TYPE_DATAPACK)
	{
		DataPack* pPack = qobject_cast<DataPack*>(pDataManager->findObjectById(DataManager::DataType::dataPack, modelid));
		if (pPack)
		{
			if (!pPack->_initScene)
			{
				if (pPack->getScene(pDataManager))
				{
					//			pPack->_initScene = true;
				}
			}
			else
			{
				parameter["error"] = "获取场景失败";
			}

			for (it = pPack->_sceneMap.begin(); it != pPack->_sceneMap.end(); ++it)
			{
				json j;
				(*it)->toJson(j);
				parameter["response"].push_back(j);
			}
		}
	}
	else
	{
		//类型错误
		parameter["error"] = "参数类型错误";
	}

	LOG(INFO) << CommonHelper::utf8ToStdString("getSceneNode Sendto web.......");
	LOG(INFO) << CommonHelper::jsonToString(parameter);
	return true;
}

bool DataPackEventModule::updateScene(json& parameter)
{
	auto data = parameter["data"];
	int id = data["id"];
	DPData* pData = pDataManager->findObjectById(DataManager::DataType::scene, id);
	SceneInfo* pScene = qobject_cast<SceneInfo*>(pData);
	if (pScene)
	{
		pScene->setNewData(parameter);
		if (pScene->saveSelf())
		{
			parameter["response"] = { {"status",true} };
		}
		else
		{
			parameter["response"] = { {"status",false} };
		}
	}
	LOG(INFO) << CommonHelper::utf8ToStdString("updateScene Sendto web.......");
	LOG(INFO) << CommonHelper::jsonToString(parameter);
	return true;
}