DPS/DataPlatform/ProjectData.cpp

#pragma execution_character_set("utf-8")

#include "ProjectData.h"
#include "DataModelData.h"
#include "DataManager.h"
#include "M_ProjectDAO.h"
#include "M_EntityModelDAO.h"
#include "CommonDataPublic.h"
#include <QTime>




void static backupDAOData(DBPlatformSpace::M_ProjectDAO& src, DBPlatformSpace::M_ProjectDAO& dst)
{
	//主要备份界面可修改的值
	dst._name = src._name;
	dst._type = src._type;
	dst._author = src._author;
}

void static restoreProjectData(DBPlatformSpace::M_ProjectDAO& src, ProjectData& dst)
{
	//主要恢复界面属性值
	dst._name = CommonHelper::stringToQstring(src._name);
	dst._type = src._type;
	dst._author = CommonHelper::stringToQstring(src._author);
}


ProjectData::ProjectData()
{

}

ProjectData::~ProjectData()
{

}

QString ProjectData::getAuthor() const
{
	return _author;
}
void ProjectData::setAuthor(QString author)
{
	this->_author = author;
}

QString ProjectData::getCreateTime() const
{
	return _createTime;
}

void ProjectData::setCreateTime(QString createTime)
{
	this->_createTime = createTime;
}

QString ProjectData::getUpdateTime() const
{
	return _updateTime;
}

void ProjectData::setUpdateTime(QString updateTime)
{
	this->_updateTime = updateTime;
}

bool ProjectData::getFocus() const
{
	return _focus;
}

void ProjectData::setFocus(bool focus)
{
	this->_focus = focus;
}

void ProjectData::removeChildinDPMap()
{
	DataManager& mgr = GetDataRoot();
	QMap<unsigned int, DPData*>::iterator it = _childrenMap.begin();
	while (it != _childrenMap.end())
	{
		mgr.deleteInDataMap(DataManager::DataType::dataModel, (*it)->_id);
		qobject_cast<DataModelData*>(*it)->removeChildinDPMap();
		it++;
	}
}


bool ProjectData::saveSelf()
{
	using namespace DBPlatformSpace;
	M_ProjectDAO oldDaoData;
	ResultMsg rm;
	/*将这条项目数据写入数据库*/
	M_ProjectDAO* pDao = dynamic_cast<M_ProjectDAO*>(_pDBDAO);

	if (pDao == nullptr)
	{
		pDao = new M_ProjectDAO();
		_pDBDAO = pDao;
	}
	else
	{
		/*备份DAO数据*/
		backupDAOData(*pDao, oldDaoData);
	}

	pDao->_name = CommonHelper::qstringToStdString(this->_name);
	pDao->_type = this->_type;
	pDao->_focus = this->_focus;
	pDao->_author = CommonHelper::qstringToStdString(this->_author);
	pDao->_createTime = CommonHelper::qstringToStdString(this->_createTime);
	pDao->_updateTime = CommonHelper::qstringToStdString(this->_updateTime);

	rm = pDao->save();

	if (rm.rCode == 0)
	{
		LOG(INFO) << CommonHelper::utf8ToStdString(" M_ProjectDAO::save success");
		return true;
	}
	else
	{
		LOG(INFO) << CommonHelper::utf8ToStdString(" M_ProjectDAO::save failed");
		LOG(ERROR) << rm.rMsg;
		//恢复数据
		restoreProjectData(oldDaoData, *this);
		return false;
	}
}

void ProjectData::loadData(DBPlatformSpace::DAO* pDao)
{
	_pDBDAO = pDao;
	//将DAO数据存入projectData对象
	DBPlatformSpace::M_ProjectDAO* pDAOData = dynamic_cast<DBPlatformSpace::M_ProjectDAO*>(_pDBDAO);
	_id = pDAOData->_ID;
	_name = CommonHelper::stringToQstring(pDAOData->_name);
	_type = pDAOData->_type;
	_focus = pDAOData->_focus;
	_author = CommonHelper::stringToQstring(pDAOData->_author);
	_createTime = CommonHelper::stringToQstring(pDAOData->_createTime);
	_updateTime = CommonHelper::stringToQstring(pDAOData->_updateTime);

}

bool ProjectData::deleteSelf()
{
	if (_pDBDAO)
	{
		//将这条数据从数据库删除
		DBPlatformSpace::ResultMsg rm = _pDBDAO->delself();
		if (rm.rCode == 0)
		{
			//数据库删除成功，从内存项目中删除该数据模型
			_parent->deleteChild(_id);
			removeChildinDPMap();

			LOG(INFO) << CommonHelper::utf8ToStdString(" M_ProjectDAO::delself success");
			return true;
		}
		LOG(INFO) << CommonHelper::utf8ToStdString(" M_ProjectDAO::delself failed");
		LOG(ERROR) << rm.rMsg;
		return false;
	}
	else
	{
		return false;
	}

}

void ProjectData::toJson(json& jsonObj, bool /*recursive*/)
{
	jsonObj["id"] = _id;
	jsonObj["author"] = CommonHelper::qstringToUtf8(getAuthor());
	jsonObj["name"] = CommonHelper::qstringToUtf8(_name);
	jsonObj["type"] = getType();
	jsonObj["createTime"] = CommonHelper::qstringToUtf8(getCreateTime());
	jsonObj["updateTime"] = CommonHelper::qstringToUtf8(getUpdateTime());
	jsonObj["focus"] = getFocus();

}

/*获取当前项目的所有数据模型*/
void ProjectData::getAllChildren(DPData* pManager)
{
	using namespace DBPlatformSpace;
	ResultMsg rm;
	DataManager* pDManager = qobject_cast<DataManager*>(pManager);

	M_ProjectDAO* pProject = dynamic_cast<M_ProjectDAO*>(_pDBDAO);
	list<M_EntityModelDAO*> listDataModel;
	rm = pProject->getEntityModelList(listDataModel);
	if (rm.rCode != 0)
	{
		LOG(INFO) << CommonHelper::utf8ToStdString(" M_ProjectDAO::getEntityModelList failed");
		LOG(ERROR) << rm.rMsg;
		return;
	}
	if (listDataModel.size() != _childrenMap.size())
	{
		qDeleteAll(_childrenMap);
		_childrenMap.clear();
	}
	LOG(INFO) << CommonHelper::utf8ToStdString(" M_ProjectDAO::getEntityModelList success");
	for (list<M_EntityModelDAO*>::iterator it = listDataModel.begin(); it != listDataModel.end(); ++it)
	{
		int id = (*it)->_ID;
		DataModelData* pNew = nullptr;
		if (_childrenMap.contains(id))
		{
			_childrenMap.value(id)->loadData(*it);
		}
		else
		{
			pNew = new DataModelData();
			pNew->loadData(*it);
			pNew->_parent = this;
			_childrenMap.insert(id, pNew);
			//加入model map
			pDManager->insertDataMap(DataManager::DataType::dataModel, pNew->_id, pNew);
		}
	}
}

/*新加数据模型到本项目*/
bool ProjectData::addChild(DPData* pNewData)
{
	using namespace DBPlatformSpace;
	ResultMsg rm;
	DataModelData* pNewModelData = qobject_cast<DataModelData*>(pNewData);
	pNewModelData->saveToDao();
	M_EntityModelDAO* pNewModelDAO = dynamic_cast<M_EntityModelDAO*>(pNewData->_pDBDAO);
	M_ProjectDAO* pProjectDAO = dynamic_cast<M_ProjectDAO*>(_pDBDAO);
	rm = pProjectDAO->addEntityModel(pNewModelDAO);
	if (rm.rCode == 0)
	{
		LOG(INFO) << CommonHelper::utf8ToStdString(" M_ProjectDAO::addEntityModel success");
		pNewModelData->_id = pNewModelDAO->_ID;
		pNewModelData->_version = pNewModelDAO->_version;
		//保存数据模型成功，添加到childMap	
		_childrenMap.insert(pNewData->_id, pNewData);
		return true;
	}
	LOG(INFO) << CommonHelper::utf8ToStdString(" M_ProjectDAO::addEntityModel failed");
	LOG(ERROR) << rm.rMsg;
	return false;
}

bool ProjectData::deleteChild(unsigned int dataModelId)
{
	_childrenMap.remove(dataModelId);
	return true;
}

void ProjectData::getNewProperty(json& parameter, QVariantMap& valueMap)
{
	auto data = parameter["data"];
	if (!data["name"].is_null())
	{
		valueMap.insert("name", CommonHelper::utf8ToQString(data["name"]));
	}
	if (!data["author"].is_null())
	{
		valueMap.insert("author", CommonHelper::utf8ToQString(data["author"]));
	}
	if (!data["type"].is_null())
	{
		valueMap.insert("type", (int)data["type"]);
	}
	if (!data["focus"].is_null())
	{
		valueMap.insert("focus", (bool)data["focus"]);
	}

}

void ProjectData::setNewData(json& parameter)
{
	//当前时间
	QString curTime = QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm");

	QVariantMap newValue;
	getNewProperty(parameter, newValue);
	newValue.insert("createTime", curTime);
	newValue.insert("updateTime", curTime);
	//保存属性
	setProperties(newValue);
}

void ProjectData::setEditData(json& parameter)
{
	//编辑项目和修改关注状态时调用 
	//需修改 更新时间
//	QString curTime = QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm");
	QVariantMap newValue;
	getNewProperty(parameter, newValue);
	//	newValue.insert("updateTime", curTime);
	setProperties(newValue);
}

bool ProjectData::getImportProjectList(QList<ProjectData*>& proList, QString importFilePath)
{
	using namespace DBPlatformSpace;
	ResultMsg rm;
	list<M_ProjectDAO*> plist;
	rm = M_ProjectDAO::getImportProjectList(plist, CommonHelper::qstringToStdString(importFilePath));
	if (rm.rCode == 0)
	{
		//list<M_ProjectDAO*>转换成 QList<ProjectData*>
		for (list<M_ProjectDAO*>::iterator it = plist.begin(); it != plist.end(); ++it)
		{
			ProjectData* pProjecct = new ProjectData();
			pProjecct->loadData(*it);
			proList.append(pProjecct);
		}

		LOG(INFO) << CommonHelper::utf8ToStdString(" M_ProjectDAO::getImportProjectList success");
		return true;
	}
	else
	{
		LOG(INFO) << CommonHelper::utf8ToStdString(" M_ProjectDAO::getImportProjectList failed");
		LOG(ERROR) << rm.rMsg;
		return false;
	}
}

bool ProjectData::importData(json& parameter, QList<int>& projectIdlist)
{
	using namespace DBPlatformSpace;
	ResultMsg rm;
	auto data = parameter["data"];
	list<int> importIds;
	for (auto j : data)
	{
		importIds.push_back(j.get<int>());
		projectIdlist.append(j.get<int>());
	}
	SysManager& sysMgr = GetSysManager();
	rm = M_ProjectDAO::importProject(CommonHelper::qstringToStdString(sysMgr._importFilePath), importIds);//导入选中的项目"
	if (rm.rCode == 0)
	{
		LOG(INFO) << CommonHelper::utf8ToStdString(" M_ProjectDAO::importProject success");
		return true;
	}
	else
	{
		LOG(INFO) << CommonHelper::utf8ToStdString(" M_ProjectDAO::importProject failed");
		LOG(ERROR) << rm.rMsg;
		return false;
	}

}

bool ProjectData::exportData(json& parameter, QString exportPath)
{
	DBPlatformSpace::ResultMsg rm;
	auto data = parameter["data"];
	list<int> projectIds;
	for (auto j : data)
	{
		projectIds.push_back(j.get<int>());
	}
	rm = DBPlatformSpace::M_ProjectDAO::exportProject(projectIds, CommonHelper::qstringToStdString(exportPath));
	if (rm.rCode == 0)
	{
		LOG(INFO) << CommonHelper::utf8ToStdString(" M_ProjectDAO::exportProject success");
		return true;
	}
	else
	{
		LOG(INFO) << CommonHelper::utf8ToStdString(" M_ProjectDAO::exportProject failed");
		LOG(ERROR) << rm.rMsg;
		return false;
	}
	return true;
}

void ProjectData::findDatamodelByName(QString name, QList<DPData*>& modellist)
{
	if (_childrenMap.size() == 0)
	{
		return;
	}
	QMap<unsigned int, DPData*>::iterator it = _childrenMap.begin();
	while (it != _childrenMap.end())
	{
		if (name.compare((*it)->_name) == 0)
		{
			modellist.append((*it));
		}
		it++;
	}
}

void ProjectData::setCurrentProject()
{
	using namespace DBPlatformSpace;
	M_ProjectDAO::setCurrProjectID(_id);
}

bool ProjectData::hasRepetitiveName(QString name, DataManager* pMgr)
{
	QMap<unsigned int, DPData*>::iterator it;
	it = pMgr->_childrenMap.begin();
	while (it != pMgr->_childrenMap.end())
	{
		ProjectData* pData = qobject_cast<ProjectData*>(*it);
		QString n = pData->property("name").toString();
		if (n == name)
		{
			return true;
		}
		it++;
	}
	return false;
}