#pragma execution_character_set("utf-8")

#include <QCoreApplication>
#include <QFileDialog>
#include <QMessageBox>
#include "global.h"
#include "DataClass.h"
#include "M_EntityTableDAO.h" //数据类
#include "M_FolderDAO.h"
#include "M_NormalColumnDAO.h"
#include "M_EntityModelDAO.h"
#include "DataManager.h"
#include "DataAttribute.h"
#include "global.h"
#include "FindByInterface.h"
#include "DelByInterface.h"
#include "M_FindByInterfaceDAO.h"
#include "M_DelByInterfaceDAO.h"
#include "DataModelData.h"
#include "DataPack.h"
#include "SceneInfo.h"
#include "M_SceneInfoDAO.h"
#include "DataRow.h"
#include < regex >
#include <QMap>

#include"filter.h"
#include "CodeGenerator.h"

//数据编辑模块，char*和double*数据
typedef struct blobData
{
	DBPlatformSpace::M_NormalColumnDAO* pCol = nullptr;
	QString  v;
	int      id;
}CHARDataToSave;


//内部使用，获取业务数据内现有id,如果
void getTableDataIds(DBPlatformSpace::M_EntityTableDAO* pT, QMap<int ,int >& idmap)
{
	list<M_NormalColumnDAO*> collist;//表头信息
	list<string> valuelist;
	pT->getData(collist,valuelist);
	if (valuelist.size() == 0) return;
	for (auto v : valuelist)
	{
		QString qv = CommonHelper::stringToQstring(v);
		QStringList vl = qv.split("@#@");
		int id = vl.front().toInt();
		idmap.insert(id, 1);
	}
}
//内部使用，获取新增的id .返回 -1 没有找到新增
int getNewId(DBPlatformSpace::M_EntityTableDAO* pT, QMap<int, int > old_Idmap)
{
	list<M_NormalColumnDAO*> collist;//表头信息
	list<string> valuelist;
	pT->getData(collist, valuelist);
	if (valuelist.size() == 0) return -1;
	for (auto v : valuelist)
	{
		QString qv = CommonHelper::stringToQstring(v);
		QStringList vl = qv.split("@#@");
		int id = vl.front().toInt();
		if (!old_Idmap.contains(id))
		{
			//如果不包含，则为new
			return id;
		}
	}
	return -1;
}


DataClass::DataClass()
{
	_baseType = g_TYPE_DATACLASS;
}

DataClass::~DataClass()
{

	//清理 查询接口map
	qDeleteAll(_findByMap);
	_findByMap.clear();
	//清理删除接口map
	qDeleteAll(_delByMap);
	_delByMap.clear();
	//清理场景
	qDeleteAll(_sceneMap);
	_sceneMap.clear();

	qDeleteAll(tableData);
	tableData.clear();
	qDeleteAll(filterItems);
	filterItems.clear();

	//qDeleteAll(_findbyFuncs);
	//_findbyFuncs.clear();
	//qDeleteAll(_delbyFuncs);
	//_delbyFuncs.clear();

}

bool static buildRelation(DPData* pMain, DPData* pSub, QString name, int type)
{
	//名称标识按CR+类名+ID, 显示名称是web传入
	DataAttribute* pNewAttribute = new DataAttribute();
	//关联数据类
	QString nameFlag = "CR" + pSub->property("name").toString() + "ID";
	pNewAttribute->setName(nameFlag);
	pNewAttribute->setDisplayName(name);
	pNewAttribute->_FKType = type;
	pNewAttribute->_wFkTableID = pSub->_id;
	pNewAttribute->_wDataType = MNORMALCOL_TYPE_INT;
	if (pMain->addChild(pNewAttribute))
	{
		pNewAttribute->_parent = pMain;
		DataManager* pManager = qobject_cast<DataManager*>(pMain->getDataManager());
		pManager->insertDataMap(DataManager::DataType::dataAttribute, pNewAttribute->_id, pNewAttribute);
		return  true;
	}
	delete pNewAttribute;
	pNewAttribute = nullptr;
	return false;
}

bool static buildMNRelationship(DPData* pClass1, DPData* pClass2, QString nameflag1, QString nameflag2, DataClass*& pNewClass)
{
	//	const int RELATED_CLASS = 2;
	//	DataManager* pManager = qobject_cast<DataManager*>(pClass1->getDataManager());
		//关系数据类的名称标识以“TR_主数据类名_关联数据类名”定义
	QString classNameFlag = "TR_" + pClass1->property("name").toString() + "_" + pClass2->property("name").toString();
	//关系数据类建在主数据类所在模块下
	pNewClass = new DataClass();
	pNewClass->setdisplayName(classNameFlag);
	pNewClass->setName(classNameFlag);
	pNewClass->_type = g_RELATED_CLASS;  //为关系数据类

	if (pClass1->_parent->addChild(pNewClass))
	{
		//将数据关系类加到map中
		DataManager* pManager = qobject_cast<DataManager*>(pClass1->getDataManager());
		pManager->insertDataMap(DataManager::DataType::dataClass, pNewClass->_id, pNewClass);
		//新建数据关系类成功，则需新建两个属性在数据关系类中
		//属性1
		DataAttribute* pNewAttribute1 = new DataAttribute();
		QString name1 = "CR" + pClass1->property("name").toString() + "ID";
		pNewAttribute1->setName(name1);
		pNewAttribute1->setDisplayName(nameflag1);
		pNewAttribute1->_wFkTableID = pClass2->_id; //这里需要给值？
		pNewAttribute1->_wDataType = MNORMALCOL_TYPE_INT;
		pNewAttribute1->_FKType = FK_1N;
		pNewAttribute1->_parent = pNewClass;
		//添加属性1
		if (pNewClass->addChild(pNewAttribute1))
		{
			//成功
			pManager->insertDataMap(DataManager::DataType::dataAttribute, pNewAttribute1->_id, pNewAttribute1);
			//属性2
			DataAttribute* pNewAttribute2 = new DataAttribute();
			QString name2 = "CR" + pClass2->property("name").toString() + "ID";
			pNewAttribute2->setDisplayName(nameflag2);
			pNewAttribute2->setName(name2);
			pNewAttribute2->_wFkTableID = pClass1->_id;
			pNewAttribute2->_FKType = FK_1N;
			pNewAttribute2->_wDataType = MNORMALCOL_TYPE_INT;
			pNewAttribute2->_parent = pNewClass;
			//添加属性2
			if (pNewClass->addChild(pNewAttribute2))
			{
				//成功
				pManager->insertDataMap(DataManager::DataType::dataAttribute, pNewAttribute2->_id, pNewAttribute2);
				return true;
			}
			else
			{
				//失败:删除属性1 2，删除数据关系类
				if (pNewClass->deleteChild(pNewAttribute1->_id))
				{
					delete pNewAttribute1;
					pNewAttribute1 = nullptr;
				}
				if (pNewClass->deleteChild(pNewAttribute2->_id))
				{
					delete pNewAttribute2;
					pNewAttribute2 = nullptr;
				}

				if (pNewClass->_parent->deleteChild(pNewClass->_id))
				{
					delete pNewClass;
					pNewClass = nullptr;
				}

				return false;
			}
		}
		else
		{
			//失败:删除属性1 ，删除数据关系类
			if (pNewClass->deleteChild(pNewAttribute1->_id))
			{
				delete pNewAttribute1;
				pNewAttribute1 = nullptr;
			}

			if (pNewClass->_parent->deleteChild(pNewClass->_id))
			{
				delete pNewClass;
				pNewClass = nullptr;
			}

			return false;
		}
	}
	else
	{
		//失败
		delete pNewClass;
		pNewClass = nullptr;
		return false;
	}
}

void static backupDAOData(DBPlatformSpace::M_EntityTableDAO& src, DBPlatformSpace::M_EntityTableDAO& dst)
{

}

void static restoreData(DBPlatformSpace::M_EntityTableDAO& src, DataClass& dst)
{
	//主要恢复界面属性值
}

/*移去所有属性*/
void DataClass::removeChildinDPMap()
{
	DataManager& mgr = GetDataRoot();
	QMap<unsigned int, DPData*>::iterator it = _childrenMap.begin();
	while (it != _childrenMap.end())
	{
		mgr.deleteInDataMap(DataManager::DataType::dataAttribute, (*it)->_id);
		it++;
	}
	QMap<int, SceneInfo*>::iterator it_sc = _sceneMap.begin();
	while (it_sc != _sceneMap.end())
	{
		mgr.deleteInDataMap(DataManager::DataType::scene, (*it_sc)->_id);
		it_sc++;
	}
}

void DataClass::saveToDao()
{
	using namespace  DBPlatformSpace;
	M_EntityTableDAO* pDao = dynamic_cast<M_EntityTableDAO*>(_pDBDAO);

	if (pDao == nullptr)
	{
		pDao = new M_EntityTableDAO();
		_pDBDAO = pDao;
	}

	pDao->_name = CommonHelper::qstringToStdString(getName());   //名称标识
	pDao->_type = _type;
	pDao->_description = CommonHelper::qstringToStdString(_strDescription);
	pDao->_displayName = CommonHelper::qstringToStdString(_strDisplayName);

	pDao->_countType = _wCountType;

}

/*保存本身数据*/
bool DataClass::saveSelf()
{
	using namespace DBPlatformSpace;
	ResultMsg rm;
	/*将这条项目数据写入数据库*/
	M_EntityTableDAO* pDao = dynamic_cast<M_EntityTableDAO*>(_pDBDAO);
	/*备份DAO数据*/
	M_EntityTableDAO oldDaoData;
	if (pDao == nullptr)
	{
		pDao = new M_EntityTableDAO();
		_pDBDAO = pDao;
	}
	else
	{
		backupDAOData(*pDao, oldDaoData);
	}
	saveToDao();
	rm = pDao->save();
	if (rm.rCode == 0)
	{
		LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.save success ");
		return true;
	}
	else
	{
		LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.save failed ");
		LOG(ERROR) << rm.rMsg;
		restoreData(oldDaoData, *this);
		return false;
	}
}

/*增加child数据*/
bool DataClass::addChild(DPData* pNewData)
{
	using namespace DBPlatformSpace;
	ResultMsg rm;
	pNewData->saveToDao();
	M_NormalColumnDAO* pNewDAO = dynamic_cast<M_NormalColumnDAO*>(pNewData->_pDBDAO);
	M_EntityTableDAO* pClassDAO = dynamic_cast<M_EntityTableDAO*>(_pDBDAO);
	//查找所属数据模型
	DPData* pDataModel = getDataModelOwner();
	M_EntityModelDAO* pModelDAO = dynamic_cast<M_EntityModelDAO*>(pDataModel->_pDBDAO);
	//将新属性的 addVersion 设置为当前数据模型version
	pNewDAO->_addVersion = pModelDAO->_version;
	rm = pClassDAO->addNormalColumnDAO(pModelDAO, pNewDAO);
	if (rm.rCode == 0)
	{
		LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.addNormalColumnDAO success ");
		QString msg = "DataClass::addChild: NormalColumn:" + QString::number(pNewDAO->_ID) + "--" + CommonHelper::stringToQstring(pNewDAO->_name) + "新建成功";
		LOG(INFO) << CommonHelper::qstringToString(msg);
		DataAttribute* pAttribute = (DataAttribute*)pNewData;
		//返回的id
		pAttribute->_id = pNewDAO->_ID;
		//建立版本
		pAttribute->_wCreateVersion = pNewDAO->_addVersion;
		//删除版本
		pAttribute->_wDeleteVersion = pNewDAO->_delVersion;
		pAttribute->_strInternalName = CommonHelper::stringToQstring(pNewDAO->_innerName);
		_childrenMap.insert(pNewData->_id, pNewData);
		return true;
	}
	else
	{
		LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.addNormalColumnDAO failed ");
		QString msg = "DataClass::addChild: NormalColumn:" + QString::number(pNewDAO->_ID) + "--" + CommonHelper::stringToQstring(pNewDAO->_name) + "新建失败";
		LOG(INFO) << CommonHelper::qstringToString(msg);
		msg = "DataClass::" + QString::number(pClassDAO->_ID) + "--" + CommonHelper::stringToQstring(pClassDAO->_name);
		LOG(INFO) << CommonHelper::qstringToString(msg);
		LOG(ERROR) << rm.rMsg;
		return false;
	}
}

/*删除一条child数据*/
bool DataClass::deleteChild(unsigned int id)
{
	if (_childrenMap.remove(id))
	{
		DataManager& dataMgr = GetDataRoot();
		dataMgr.deleteInDataMap(DataManager::DataType::dataAttribute, id);
		return true;
	}
	else
	{
		return false;
	}
}


/*移去类下所有场景*/
void DataClass::removeSceneinDPMap()
{
	DataManager& mgr = GetDataRoot();
	QMap<int, SceneInfo*>::iterator it = _sceneMap.begin();
	while (it != _sceneMap.end())
	{
		mgr.deleteInDataMap(DataManager::DataType::scene, (*it)->_id);
		it++;
	}
}

/*删除本对象,返回删除的id与类型*/
bool DataClass::deleteFromModel(QString& result)
{
	LOG(INFO) << CommonHelper::utf8ToStdString("DataClass::deleteFromModel ");
	//	testfun();
	using namespace DBPlatformSpace;
	if (_pDBDAO)
	{
		DPData* pDataModel = getDataModelOwner();
		std::string deletedResult;
		M_EntityModelDAO* pModelDAO = dynamic_cast<M_EntityModelDAO*>(pDataModel->_pDBDAO);
		M_EntityTableDAO* pclassDao = dynamic_cast<M_EntityTableDAO*>(_pDBDAO);
		ResultMsg rm = pclassDao->delFromEntityModel(pModelDAO, deletedResult);
		if (rm.rCode == 0)
		{
			LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.delFromEntityModel success ");
			QString msg = "M_EntityTableDAO:" + QString::number(_id) + "--" + _name + "删除成功";
			LOG(INFO) << CommonHelper::qstringToString(msg);
			result = CommonHelper::stringToQstring(deletedResult);
			resolveDeleteResult(result);
			if (_parent)
			{
				DataManager& datamgr = GetDataRoot();
				removeChildinDPMap();
				removeSceneinDPMap();
				_parent->deleteChild(_id);
				datamgr.deleteInDataMap(DataManager::DataType::dataClass, _id);
				return true;
			}
			else
			{
				//_parent为空
				return false;
			}
		}
		else
		{
			LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.delFromEntityModel failed ");
			LOG(ERROR) << rm.rMsg;
			//数据库删除失败
			return false;
		}
	}
	else
	{
		//_pDBDAO为空
		LOG(ERROR) << CommonHelper::utf8ToStdString("_pDBDao is null");
		return false;
	}
}


/*从数据库加载一条数据到当前对象*/
void DataClass::loadData(DBPlatformSpace::DAO* pDao)
{
	_pDBDAO = pDao;
	DBPlatformSpace::M_EntityTableDAO* pTableDAO = dynamic_cast<DBPlatformSpace::M_EntityTableDAO*>(_pDBDAO);
	setID(pTableDAO->_ID);
	setName(CommonHelper::stringToQstring(pTableDAO->_name));
	setdisplayName(CommonHelper::stringToQstring(pTableDAO->_displayName));
	setDescription(CommonHelper::stringToQstring(pTableDAO->_description));
	setInternalName(CommonHelper::stringToQstring(pTableDAO->_innerName));
	_wCreateVersion = pTableDAO->_addVersion;
	_wDeleteVersion = pTableDAO->_delVersion;
	_wCountType = pTableDAO->_countType;
	_type = pTableDAO->_type;
	_version = pTableDAO->_version;

}

/*获取所有下层数据*/
void DataClass::getAllChildren(DPData* pManager)
{
	using namespace DBPlatformSpace;
	ResultMsg rm;
	DataManager* pMng = qobject_cast<DataManager*>(pManager);
	list<M_NormalColumnDAO*> attributeDAOList;
	M_EntityTableDAO* pTableDao = dynamic_cast<M_EntityTableDAO*>(_pDBDAO);

	//查找所属数据模型
	DPData* pDataModel = getDataModelOwner();
	M_EntityModelDAO* pModelDAO = dynamic_cast<M_EntityModelDAO*>(pDataModel->_pDBDAO);
	rm = pTableDao->getNormalColumnDAOList(pModelDAO, attributeDAOList);
	if (rm.rCode != 0)
	{
		LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.getNormalColumnDAOList failed ");
		LOG(ERROR) << rm.rMsg;
		return;
	}
	LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.getNormalColumnDAOList success ");
	for (list<M_NormalColumnDAO*>::iterator it = attributeDAOList.begin(); it != attributeDAOList.end(); ++it)
	{
		DataAttribute* pNew = new DataAttribute();
		pNew->loadData(*it);
		int id = (*it)->_ID;
		pNew->_parent = this;
		_childrenMap.insert(id, pNew);
		pMng->insertDataMap(DataManager::DataType::dataAttribute, id, pNew);
	}
	_initAttriute = true;
}

/*获取新的属性*/
void DataClass::getNewProperty(json& parameter, QVariantMap& valueMap)
{
	auto data = parameter["data"];
	//显示名称
	valueMap.insert("displayName", CommonHelper::utf8ToQString(data["label"]));
	//名称标识
	if (!data["name"].is_null())
	{
		valueMap.insert("name", CommonHelper::utf8ToQString(data["name"]));
	}
	//描述
	valueMap.insert("description", CommonHelper::utf8ToQString(data["description"]));
	//数量类型
	valueMap.insert("countType", (unsigned int)(data["countType"]));
}

void DataClass::setNewData(json& parameter)
{
	QVariantMap newValues;
	getNewProperty(parameter, newValues);
	setProperties(newValues);
}

void DataClass::toJson(json& jsonObj, bool recursive)
{
	jsonObj["id"] = _id;
	jsonObj["label"] = CommonHelper::qstringToUtf8(_strDisplayName);
	jsonObj["name"] = CommonHelper::qstringToUtf8(_name);
	jsonObj["type"] = _type;
	jsonObj["description"] = CommonHelper::qstringToUtf8(_strDescription);
	jsonObj["classType"] = g_TYPE_DATACLASS;
	jsonObj["createVersion"] = _wCreateVersion;
	jsonObj["delVersion"] = _wDeleteVersion;
	jsonObj["innerName"] = CommonHelper::qstringToUtf8(_strInternalName);
	jsonObj["countType"] = _wCountType;
	
	
	using namespace DBPlatformSpace;
		
	M_EntityTableDAO* pTable = static_cast<M_EntityTableDAO*>(_pDBDAO);
	string name = pTable->tableNameToDAOName(pTable->_name);
	_tableName = QString::fromStdString(name);
	jsonObj["tableName"] = CommonHelper::stringToUtf8(name);
	

	if (recursive)
	{
		if (_childrenMap.size() == 0)
		{
			return;
		}
		json attributes;
		//数据类下的属性
		QMap<unsigned int, DPData*>::iterator it = _childrenMap.begin();
		while (it != _childrenMap.end())
		{
			//将对象信息转json
			json child;
			(*it)->toJson(child);
			attributes.push_back(child);
			it++;
		}
		jsonObj["attributes"] = attributes;
	}
}

//将当前数据类移入新的数据模块
bool DataClass::moveData(json& parameter, DPData* pManager)
{
	using namespace DBPlatformSpace;
	ResultMsg rm;
	DataManager* pMng = qobject_cast<DataManager*>(pManager);
	//目的模块
	auto data = parameter["data"];
	int dstPackId = data["parentid"];
	DataPack* pdstPack = qobject_cast<DataPack*>(pMng->findObjectById(DataManager::DataType::dataPack, dstPackId));
	M_FolderDAO* pDstPackDAO = dynamic_cast<M_FolderDAO*>(pdstPack->_pDBDAO);
	if (!pDstPackDAO)
	{
		return false;
	}
	//当前数据类DAO
	M_EntityTableDAO* pClassDAO = dynamic_cast<M_EntityTableDAO*>(_pDBDAO);
	//上层数据模块DAO
	M_FolderDAO* pfatherPackDAO = dynamic_cast<M_FolderDAO*>(_parent->_pDBDAO);
	//从上层数据模块移出
	rm = pfatherPackDAO->removeM_EntityTableDAO(pClassDAO);
	if (rm.rCode == 0)
	{
		//移出成功 
		LOG(INFO) << CommonHelper::utf8ToStdString("M_FolderDAO.removeM_EntityTableDAO success ");
		//移入
		rm = pDstPackDAO->addM_EntityTableDAO(pClassDAO);
		if (rm.rCode == 0)
		{
			LOG(INFO) << CommonHelper::utf8ToStdString("M_FolderDAO.addM_EntityTableDAO success ");
			//移入成功, 从上层结点的children表中移除
			_parent->_childrenMap.remove(_id);
			//指向新的父类
			_parent = pdstPack;
			pdstPack->_childrenMap.insert(_id, this);
			return true;
		}
		else
		{
			LOG(INFO) << CommonHelper::utf8ToStdString("M_FolderDAO.addM_EntityTableDAO failed ");
			LOG(ERROR) << rm.rMsg;
			//移入失败
			return false;
		}
	}
	else
	{
		LOG(INFO) << CommonHelper::utf8ToStdString("M_FolderDAO.removeM_EntityTableDAO failed ");
		LOG(ERROR) << rm.rMsg;
		//移出失败
		return false;
	}
}

bool DataClass::buildRelationship(DPData* pClass1, DPData* pClass2, QString name1, QString name2, int type, DataClass*& pNewClass)
{
	switch (type)
	{
	case RELATION_MN:
		return buildMNRelationship(pClass1, pClass2, name1, name2, pNewClass);
	case RELATION_11:
		return buildRelation(pClass1, pClass2, name1, FK_11);
	case RELATION_1N:
		return buildRelation(pClass2, pClass1, name1, FK_1N);
	case RELATION_N1:
		return buildRelation(pClass1, pClass2, name1, FK_1N);
	default:
		break;
	}
	return false;
}


//删除mn关系
bool DataClass::deleteMNrealationship(DPData* pClass1, DPData* pClass2, QString& result)
{
	//如果pclass1是数据关系类，直接删除该类即可
	DataClass* pClassA = qobject_cast<DataClass*>(pClass1);
	if (pClassA->_type == g_RELATED_CLASS)
	{
		if (pClassA->deleteFromModel(result))
		{
			result = QString::number(g_TYPE_DATACLASS) + "," + QString::number(pClassA->_id);
			return true;
		}
		return false;
	}
	DataClass* pClassB = qobject_cast<DataClass*>(pClass2);
	if (pClassB->_type == g_RELATED_CLASS)
	{
		if (pClassB->deleteFromModel(result))
		{
			result = QString::number(g_TYPE_DATACLASS) + "," + QString::number(pClassB->_id);
			return true;
		}
		return false;
	}
	//两都不是数据关系类，返回false,说明非mn关系
	return false;
}

//result保存删除关系同时删除的属性信息，返回 
bool DataClass::deleteRelationship(DPData* pClass1, DPData* pClass2, QString& result)
{	 //pclass1这主类（属性在该类下）
	using namespace DBPlatformSpace;
	ResultMsg rm;
	QString idAndType;  // "id,type"

	//如果是mn关系，有一类是数据关系类
	if (deleteMNrealationship(pClass1, pClass2, result))
	{
		return true;
	}
	else
	{
		//是1:1 1:n n:1 关系
			//删除class1中 关联class2的属性
		int deleteAttributeId = 0;  //要删除的属性id
		QMap<unsigned int, DPData*>::iterator it;
		it = pClass1->_childrenMap.begin();
		while (it != pClass1->_childrenMap.constEnd())
		{
			if ((*it)->property("fkTableId") == pClass2->_id)
			{
				deleteAttributeId = (*it)->_id;
				break;
			}
			++it;
		}

		if (deleteAttributeId != 0)
		{
			DPData* deleteAttribute = pClass1->_childrenMap.value(deleteAttributeId);
			//删除属性
			if (deleteAttribute->deleteSelf())
			{
				//该属性id需返回给web
				idAndType = QString::number(g_TYPE_DATAATTRUBUTE) + "," + QString::number(deleteAttribute->_id);
				result = idAndType;
				delete deleteAttribute;
				deleteAttribute = nullptr;
				return true;
			}
			else
			{
				LOG(INFO) << CommonHelper::utf8ToStdString("属性删除失败");
				return false;
			}
		}
	}

	return true;
}

bool DataClass::resolveDeleteResult(QString deletedResult)
{
	QString msg = "DPData::resolveDeleteResult:  " + deletedResult;
	LOG(INFO) << CommonHelper::qstringToString(msg);
	if (deletedResult != "")
	{
		DataManager& dataMgr = GetDataRoot();
		QStringList typeIdlist = deletedResult.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();
			//查找属性
			if (type == g_TYPE_DATAATTRUBUTE)
			{
				DataAttribute* pAttribute = qobject_cast<DataAttribute*>(dataMgr.findObjectById(DataManager::DataType::dataAttribute, id));
				if (pAttribute->deleteSelf())
				{
					//	pAttribute->_parent->deleteChild(id);
					//	dataMgr.deleteInDataMap(DataManager::DataType::dataAttribute, id);
					delete pAttribute;
					pAttribute = nullptr;
				}
			}
			else if (type == g_TYPE_DATACLASS)
			{
				DataClass* pClass = qobject_cast<DataClass*>(dataMgr.findObjectById(DataManager::DataType::dataClass, id));
				QString str;
				if (pClass->deleteFromModel(str))
				{
					//	pClass->_parent->deleteChild(id);
					//	dataMgr.deleteInDataMap(DataManager::DataType::dataClass, id);
					delete pClass;
					pClass = nullptr;
				}
			}
			else if (type == g_TYPE_SCENEINFO)
			{
				SceneInfo* pScene = qobject_cast<SceneInfo*>(dataMgr.findObjectById(DataManager::DataType::scene, id));
				if (pScene)
				{
					if (pScene->deleteSelf())
					{
						if (pScene->_parentType == g_TYPE_DATACLASS)
						{
							DataClass* pClass = qobject_cast<DataClass*>(pScene->_parent);
							pClass->_sceneMap.remove(id);
						}
						else if (pScene->_parentType == g_TYPE_DATAPACK)
						{
							DataPack* pack = qobject_cast<DataPack*>(pScene->_parent);
							pack->_sceneMap.remove(id);
						}
						dataMgr.deleteInDataMap(DataManager::DataType::scene, id);
						delete pScene;
						pScene = nullptr;
					}
				}

			}
		}
	}
	return true;
}

void DataClass::dictToJson(json& jsonObj)
{
	using namespace DBPlatformSpace;
	ResultMsg rm;
	jsonObj = json::array();
	//获取字典数据
	list<M_NormalColumnDAO*> headlist;//表头信息
	list<string> valuelist;  // 其它数据
		//组件接口获取数据
	M_EntityTableDAO* pTable = dynamic_cast<M_EntityTableDAO*>(_pDBDAO);
	rm = pTable->exportData(headlist, valuelist);
	if (rm.rCode != 0)
	{
		if (rm.rMsg != "未查询到数据")
		{
			LOG(INFO) << CommonHelper::utf8ToStdString("dictToJson:M_EntityTableDAO.exportData  failed");
			LOG(INFO) << rm.rMsg;
			return;
		}
	}
	LOG(INFO) << CommonHelper::utf8ToStdString("dictToJson:M_EntityTableDAO.exportData  success");
	if (valuelist.size() == 0)
	{
		//数据字典没有数据
		LOG(INFO) << CommonHelper::utf8ToStdString("dictToJson : Dict has no data !  ");
		return;
	}

	list<string>::iterator value_it = valuelist.begin();
	while (value_it != valuelist.end())
	{
		int index = 0;
		QStringList v = CommonHelper::stringToQstring((*value_it)).split("@#@");
		json j;
		list<M_NormalColumnDAO*>::iterator it = headlist.begin();
		while (it != headlist.end())
		{
			string item = (*it)->_name;//名称标识
			QString value = v.at(index);
			j[item] = CommonHelper::qstringToUtf8(value);
			index++;
			it++;
		}
		jsonObj.push_back(j);
		value_it++;
	}
}

bool DataClass::importDict(QString& retMsg)
{
	using namespace DBPlatformSpace;
	ResultMsg rm;
	QList<QStringList> dictionaryData; //数据字典表数据
	//组件接口
	M_EntityTableDAO* pTableDAO = dynamic_cast<M_EntityTableDAO*>(_pDBDAO);
	bool hasEmptyCell;
	QString curPath = QCoreApplication::applicationDirPath();
	QString selectDir = QFileDialog::getOpenFileName(nullptr, "选择导入文件", "", "*.xlsx");
	if (!selectDir.isEmpty())
	{
		if (!excel.OpenFile(selectDir))
		{
			QString msg = "DataClass::importDict:打开文件" + selectDir + "失败";
			LOG(ERROR) << CommonHelper::qstringToString(msg);
			return false;
		}
		if (!excel.readSheetData("数据字典类", dictionaryData, hasEmptyCell))
		{
			retMsg = "读取导入文件失败";
			return false;
		}
		//如果有空单元格数据
		if (hasEmptyCell)
		{
			QString dlgTitle = "数据字典类导入";
			QString msgInfo = "导入文件数据不完整，是否按默认数据导入？";
			QMessageBox::StandardButton  defaultBtn = QMessageBox::NoButton;
			QMessageBox::StandardButton  result;
			result = QMessageBox::question(nullptr, dlgTitle, msgInfo, QMessageBox::Yes | QMessageBox::No, defaultBtn);
			if (result == QMessageBox::No)
			{
				retMsg = "";
				return false;
			}
		}
		//把 数据存入数据库
		list<M_NormalColumnDAO*> collist;//表头信息
		QStringList headlist; //数据库中的表头信息
		list<string> valuelist;  // 其它数据
		//获取表头 list<M_NormalColumnDAO*>
		DataModelData* pModel = qobject_cast<DataModelData*>(getDataModelOwner());
		M_EntityModelDAO* pEntityModel1 = dynamic_cast<M_EntityModelDAO*>(pModel->_pDBDAO);

		pTableDAO->getNormalColumnDAOList(pEntityModel1, collist);
		//读入的表头信息与属性列表比较
		list<M_NormalColumnDAO*>::iterator it = collist.begin();
		while (it != collist.end())
		{
			headlist.append(CommonHelper::stringToQstring((*it)->_name));
			it++;
		}
		if (!CommonHelper::compareQStringlist(headlist, dictionaryData[0]))
		{
			//表头不相同
			LOG(INFO) << CommonHelper::utf8ToStdString("数据字典导入表与目标数据类属性列表不同");
			retMsg = "数据字典导入表与目标数据类属性列表不同";
			return false;
		}

		//其它数据
		for (int i = 1; i < dictionaryData.size(); i++)
		{
			QString data = dictionaryData[i].join("@#@");
			string value = CommonHelper::qstringToStdString(data);
			valuelist.push_back(value);
		}

		try
		{
			rm = pTableDAO->importData(collist, valuelist);
			if (rm.rCode != 0)
			{
				LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.importData  failed");
				LOG(INFO) << rm.rMsg;
				retMsg = "数据字典导入失败";
				return false;
			}
			LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.importData  success");
		}
		catch (exception& e)
		{
			LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.importData  failed");
			retMsg = "数据字典导入失败";
			return false;
		}
	}
	else
	{
		//未选择路径
		LOG(INFO) << CommonHelper::utf8ToStdString("未选择导入文件");
		return false;
	}
	return true;
}

/*返回值：0 成功  1 失败  2 导出模板未指定*/
int DataClass::exportTemplate()
{
	QList<QStringList> tableValue; //所有写入数据库的数据
	QStringList headstr;

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

	if (file.isEmpty())
	{
	//	LOG(INFO) << CommonHelper::utf8ToStdString(" 导出模板未指定，取消导出");
		return 2;
	}

	QFileInfo openfile(file);
	if (openfile.isFile())
	{
		//如果该文件存在，
		if (excel.OpenFile(file))
		{
			excel.clearAllSheet();
		}
		else
		{
			return 1;
		}
	}
	else
	{
		excel.clearAllSheet();
	}


	QMap<unsigned int, DPData*>::iterator it = _childrenMap.begin();
	while (it != _childrenMap.end())
	{
		QString name = (*it)->_name;
		headstr.append(name);
		it++;
	}
	tableValue.append(headstr);
	excel.writeSheetData("数据字典类", tableValue);
	excel.saveFile(file);
	return 0;
}

bool DataClass::exportDict()
{
	using namespace DBPlatformSpace;
	ResultMsg rm;
	list<M_NormalColumnDAO*> headlist;//表头信息
	list<string> valuelist;  // 其它数据
	QList<QStringList> tableValue; //所有写入数据库的数据
	QStringList headstr;
	list<string>::iterator it_list;

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

	if (file.isEmpty())
	{
		LOG(INFO) << CommonHelper::utf8ToStdString("导出文件未指定");
		return false;
	}

	QFileInfo openfile(file);
	if (openfile.isFile())
	{
		//如果该文件存在，
		if (excel.OpenFile(file))
		{
			excel.clearAllSheet();
		}
		else
		{
			return false;
		}
	}
	else
	{
		excel.clearAllSheet();
	}

	//组件接口获取数据
	M_EntityTableDAO* pTable = dynamic_cast<M_EntityTableDAO*>(_pDBDAO);
	rm = pTable->exportData(headlist, valuelist);
	if (rm.rCode != 0)
	{
		LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.exportData  failed");
		LOG(INFO) << rm.rMsg;
		return false;
	}
	LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.exportData  success");
	if (valuelist.size() == 0)
	{
		//数据字典没有数据
		LOG(INFO) << CommonHelper::utf8ToStdString("exportDict : Dict has no data !  ");
		return false;
	}
	//把headlist转为 Qstringlist
	list<M_NormalColumnDAO*>::iterator it;
	for (it = headlist.begin(); it != headlist.end(); it++)
	{
		headstr.append(CommonHelper::stringToQstring((*it)->_name));
	}

	tableValue.append(headstr);
	for (it_list = valuelist.begin(); it_list != valuelist.end(); it_list++)
	{
		string rowValue = *it_list;
		QStringList value = (CommonHelper::stringToQstring(rowValue)).split("@#@");
		tableValue.append(value);
	}

	//将数据写入excel表
	excel.writeSheetData("数据字典类", tableValue);
	excel.saveFile(file);
	return true;
}

bool DataClass::getFindByInterface()
{
	using namespace DBPlatformSpace;
	ResultMsg rm;
	list<M_FindByInterfaceDAO*> findBylist;
	rm = M_FindByInterfaceDAO::FindByT_M_EntityTableID(_id, findBylist);
	//	M_EntityTableDAO* p = dynamic_cast<M_EntityTableDAO*>(_pDBDAO);
	if (rm.rCode == 0)
	{
		LOG(INFO) << CommonHelper::utf8ToStdString("M_FindByInterfaceDAO.FindByT_M_EntityTableID  success");
		if (findBylist.size() > 0)
		{
			qDeleteAll(_findByMap);
			_findByMap.clear();
		}
		for (list<M_FindByInterfaceDAO*>::iterator it = findBylist.begin(); it != findBylist.end(); ++it)
		{
			FindByInterface* pNew = new FindByInterface();
			pNew->loadData(*it);
			_findByMap.insert(pNew->_id, pNew);
		}
		return true;
	}
	LOG(INFO) << CommonHelper::utf8ToStdString("M_FindByInterfaceDAO.FindByT_M_EntityTableID   failed");
	LOG(INFO) << rm.rMsg;
	return false;
}

bool DataClass::getDelByInterface()
{
	using namespace DBPlatformSpace;
	ResultMsg rm;
	list<M_DelByInterfaceDAO*> delByDAOlist;
	//	M_EntityTableDAO* p = dynamic_cast<M_EntityTableDAO*>(_pDBDAO);
	rm = M_DelByInterfaceDAO::FindByT_M_EntityTableID(_id, delByDAOlist);
	if (rm.rCode == 0)
	{
		LOG(INFO) << CommonHelper::utf8ToStdString("M_DelByInterfaceDAO.FindByT_M_EntityTableID  success");
		if (delByDAOlist.size() > 0)
		{
			qDeleteAll(_delByMap);
			_delByMap.clear();
		}
		for (list<M_DelByInterfaceDAO*>::iterator it = delByDAOlist.begin(); it != delByDAOlist.end(); ++it)
		{
			DelByInterface* pNew = new DelByInterface();
			pNew->loadData(*it);
			_delByMap.insert(pNew->_id, pNew);
		}
		return true;
	}
	LOG(INFO) << CommonHelper::utf8ToStdString("M_DelByInterfaceDAO.FindByT_M_EntityTableID   failed");
	LOG(INFO) << rm.rMsg;
	return false;
}

bool DataClass::addFindByInterface(FindByInterface* pNew)
{
	using namespace DBPlatformSpace;
	ResultMsg rm;
	M_EntityTableDAO* ptableDAO = dynamic_cast<M_EntityTableDAO*>(_pDBDAO);
	pNew->saveToDao();
	M_FindByInterfaceDAO* pFindByDao = dynamic_cast<M_FindByInterfaceDAO*>(pNew->_pDBDAO);

	rm = ptableDAO->addFindByInterfaceDAO(pFindByDao);
	if (rm.rCode == 0)
	{
		LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.addFindByInterfaceDAO  success");
		pNew->_id = pFindByDao->_ID;
		_findByMap.insert(pNew->_id, pNew);
		return true;
	}
	LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.addFindByInterfaceDAO   failed");
	LOG(INFO) << rm.rMsg;
	return false;
}

bool DataClass::delFindByInterfaceById(int id)
{
	using namespace DBPlatformSpace;
	ResultMsg rm;
	FindByInterface* pdata = _findByMap.value(id);
	if (pdata->deleteSelf())
	{
		//删除findby接口成功，从findbylist中删除
		_findByMap.remove(id);
		delete pdata;
		pdata = nullptr;
		return true;
	}
	return false;
}

bool DataClass::updateFindByInterfaceById(json& parameter)
{
	using namespace DBPlatformSpace;
	ResultMsg rm;
	auto data = parameter["data"];
	int id = data["id"];

	FindByInterface* pdata = _findByMap.value(id);
	pdata->setNewData(parameter);

	if (pdata->saveSelf())
	{
		return true;
	}
	else
	{
		//修改查询接口失败
		return false;
	}
}


bool DataClass::addDelByInterface(DelByInterface* pNew)
{
	using namespace DBPlatformSpace;
	ResultMsg rm;
	M_EntityTableDAO* ptableDAO = dynamic_cast<M_EntityTableDAO*>(_pDBDAO);
	pNew->saveToDao();
	M_DelByInterfaceDAO* pDelByDao = dynamic_cast<M_DelByInterfaceDAO*>(pNew->_pDBDAO);

	rm = ptableDAO->addDelByInterfaceDAO(pDelByDao);
	if (rm.rCode == 0)
	{
		pNew->_id = pDelByDao->_ID;
		_delByMap.insert(pNew->_id, pNew);
		LOG(INFO) << CommonHelper::utf8ToStdString("M_DelByInterfaceDAO.addDelByInterfaceDAO   success");
		return true;
	}
	LOG(INFO) << CommonHelper::utf8ToStdString("M_DelByInterfaceDAO.addDelByInterfaceDAO   failed");
	LOG(INFO) << rm.rMsg;
	return false;
}

bool DataClass::delDelByInterfaceById(int id)
{
	using namespace DBPlatformSpace;
	ResultMsg rm;
	DelByInterface* pdata = _delByMap.value(id);
	if (pdata->deleteSelf())
	{
		//删除delby接口成功，从findbylist中删除
		_delByMap.remove(id);
		delete pdata;
		pdata = nullptr;
		return true;
	}
	return false;
}

bool DataClass::updateDelByInterfaceById(json& parameter)
{
	using namespace DBPlatformSpace;
	ResultMsg rm;
	auto data = parameter["data"];
	int id = data["id"];

	DelByInterface* pdata = _delByMap.value(id);
	pdata->setNewData(parameter);
	if (pdata->saveSelf())
	{
		return true;
	}
	else
	{
		//修改接口失败
		return false;
	}
	return true;
}

bool  DataClass::addScene(DPData* pNew)
{
	using namespace  DBPlatformSpace;
	ResultMsg rm;
	SceneInfo* pScene = qobject_cast<SceneInfo*>(pNew);
	DPData* pModel = getDataModelOwner();
	M_EntityModelDAO* pModelDao = nullptr;
	if (pModel)
	{
		pModelDao = dynamic_cast<M_EntityModelDAO*>(pModel->_pDBDAO);
	}
	else
	{
		LOG(ERROR) << CommonHelper::utf8ToStdString("can't find datamodelOwner");
		return false;
	}
	//组件添加数据库
	M_EntityTableDAO* pClassDao = dynamic_cast<M_EntityTableDAO*>(_pDBDAO);
	pScene->saveToDao();
	M_SceneInfoDAO* pSceneDao = dynamic_cast<M_SceneInfoDAO*>(pScene->_pDBDAO);
	rm = pClassDao->addSceneInfo(pModelDao, pSceneDao);
	if (rm.rCode == 0)
	{
		pScene->_id = pSceneDao->_ID;
		pScene->_parentId = pSceneDao->_parentID;
		pScene->_parent = this;
		_sceneMap.insert(pScene->_id, pScene);
		LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.addSceneInfo success");
		return true;
	}
	else
	{
		LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.addSceneInfo failed");
		LOG(INFO) << rm.rMsg;
		return false;
	}
}

bool DataClass::deleteScene(int id)
{
	_sceneMap.remove(id);
	return true;
}

//bool DataClass::moveScene(json& parameter)
//{
//	return true;
//}

bool DataClass::getScene(DPData* pMng)
{
	DataManager* pManager = qobject_cast<DataManager*>(pMng);
	//获取
	using namespace DBPlatformSpace;
	ResultMsg rm;
	list<M_SceneInfoDAO*> sceneList;
	DPData* pModel = getDataModelOwner();
	M_EntityModelDAO* pModelDao = nullptr;
	if (pModel)
	{
		pModelDao = dynamic_cast<M_EntityModelDAO*>(pModel->_pDBDAO);
	}
	else
	{
		LOG(ERROR) << CommonHelper::utf8ToStdString("can't find datamodelOwner");
		return false;
	}
	M_EntityTableDAO* pClassDao = dynamic_cast<M_EntityTableDAO*>(_pDBDAO);

	rm = pClassDao->getSceneInfoList(pModelDao, sceneList);
	//若两者不等，重新加载,以防与数据库不一致
	if (sceneList.size() != _sceneMap.size())
	{
		qDeleteAll(_sceneMap);
		_sceneMap.clear();
	}
	if (rm.rCode == 0)
	{
		for (list<M_SceneInfoDAO*>::iterator it = sceneList.begin(); it != sceneList.end(); ++it)
		{
			SceneInfo* pScene;
			if (_sceneMap.contains((*it)->_ID))
			{
				//确保统一，可从数据库覆盖
				pScene = _sceneMap.value((*it)->_ID);
				pScene->loadData(*it);
			}
			else
			{
				pScene = new SceneInfo();
				pScene->loadData(*it);
				pScene->_parent = this;
				_sceneMap.insert(pScene->_id, pScene);
				pManager->insertDataMap(DataManager::DataType::scene, pScene->_id, pScene);
			}
		}
		LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.getSceneInfoList success");
		return true;
	}
	else
	{
		LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.getSceneInfoList failed");
		LOG(INFO) << rm.rMsg;
		return false;
	}
}

QString DataClass::getWhiteBoxType()
{
	using namespace DBPlatformSpace;
	string whiteBoxStListStr; //白盒接口类型字符串
	M_EntityTableDAO* pClassDao = dynamic_cast<M_EntityTableDAO*>(_pDBDAO);

	whiteBoxStListStr = pClassDao->_whiteBoxType;


	return CommonHelper::stringToQstring(whiteBoxStListStr);
}

bool DataClass::setWhiteBoxType(json& parameter)
{
	auto data = parameter["data"];
	int code = data["code"];
	bool status = data["status"];
	DBPlatformSpace::M_EntityTableDAO* pClassDao = dynamic_cast<DBPlatformSpace::M_EntityTableDAO*>(_pDBDAO);
	//获得现存的。
	QString whiteboxStr = CommonHelper::stringToQstring(pClassDao->_whiteBoxType);
// 	if (whiteboxStr.isEmpty())
// 	{
// 		whiteboxStr = "1:1,2:1,3:1,4:1,5:1,6:1,7:1";
// 	}
	int pos = whiteboxStr.indexOf(QString::number(code));
	int st = (status == true) ? 1 : 0;
	whiteboxStr.replace(pos + 2, 1, QString::number(st));
	pClassDao->_whiteBoxType = CommonHelper::qstringToStdString(whiteboxStr);
	DBPlatformSpace::ResultMsg rm = pClassDao->save();
	if (rm.rCode == 0)
	{
		LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.getSceneInfoList success");
		return true;
	}
	else
	{
		LOG(ERROR) << CommonHelper::utf8ToStdString("M_EntityTableDAO.getSceneInfoList failed");
		LOG(ERROR) << rm.rMsg;
		return false;
	}
}

//加T_并判断第3位是否为字母
void DataClass::reName()
{
	QString head = _name.left(2);
	if (head != "T_")
	{
		_name = "T_" + _name;
	}
}


void DataClass::setFileData(FileGenerate* generator, QStringList flag)
{
	//	int pos = flag.size();
	QString chapterName = _strDisplayName + "(" + _name + ")";

	if (flag.size() == 2)
	{
		//第一层数据类
		generator->classGroupItem.append(new CCS_Report::CCSModelDataSet(flag[0], flag[1]));
		generator->classname.append(new CCS_Report::CCSModelDataSet(flag[0], flag[1], chapterName/*_strDisplayName*/));
		if (_fkTableName.size() > 0)
		{
			for (int i = 0; i < _fkTableName.size(); i++)
			{
				generator->relatTableData.append(new CCS_Report::CCSModelDataSet(flag[0], flag[1], _fkTableName[i], _fkTypeName[i], _relTableName[i]));
			}
		}
	}
	else if (flag.size() == 3)
	{
		//第二层
		generator->classGroupItem111.append(new CCS_Report::CCSModelDataSet(flag[0], flag[1], flag[2]));
		generator->classname5.append(new CCS_Report::CCSModelDataSet(flag[0], flag[1], flag[2], chapterName/*_strDisplayName*/));
		if (_fkTableName.size() > 0)
		{
			for (int i = 0; i < _fkTableName.size(); i++)
			{
				generator->relatTableData111.append(new CCS_Report::CCSModelDataSet(flag[0], flag[1], flag[2], _fkTableName[i], _fkTypeName[i], _relTableName[i]));
			}
		}
	}

	if (_childrenMap.size() > 0)
	{ //属性
		QMap<unsigned int, DPData*>::iterator it = _childrenMap.begin();
		while (it != _childrenMap.end())
		{
			(*it)->setFileData(generator, flag);
			it++;
		}
	}
	if (_findByMap.size() > 0)
	{
		QMap<int, FindByInterface*>::iterator find_it = _findByMap.begin();
		while (find_it != _findByMap.end())
		{
			(*find_it)->setFileData(generator, flag);
			find_it++;
		}
	}
	if (_delByMap.size() > 0)
	{
		QMap<int, DelByInterface*>::iterator del_it = _delByMap.begin();
		while (del_it != _delByMap.end())
		{
			(*del_it)->setFileData(generator, flag);
			del_it++;
		}
	}
}


//合法 true. 不合法 false
bool DataClass::checkNameSize(int min, int max, QString& errMsg)
{
	if (_name.size() >=min && _name.size() <= max )
	{
		return true;
	}
	errMsg = "数据类名称标识长度不合法:" + _name;
	return false;
}

//判断第index+1位 是不是字母，是返回true, 否返回false
bool DataClass::checkLetter(QString& errmsg, int index)
{
	if (_name.at(index).isLetter())
	{
		return true;
	}
	errmsg = "数据类名称标识第" + QString::number(index + 1) + "位需为字母：" + _name;
	return false;
}

//判断其它合法性, 全部为合法字符返回true, 
bool DataClass::checkNameillegal(QString& errMsg)
{
	bool foundmatch = false;
	try {
		std::regex re(R"(^[\w\(\)\[\]\（\）]+$)");
		foundmatch = std::regex_search(_name.toStdString(), re);
	}
	catch (std::regex_error& e) {
		// Syntax error in the regular expression
	}
	if (foundmatch)
	{//合法
		return true;
	}
	else
	{
		errMsg = "名称标识 " + _name + " 含无效字符";
		return false;
	}
	return true; //合法
}

bool DataClass::getAllDataToJson(json& jsonObj)
{
	qDeleteAll(tableData);
	tableData.clear();

	using namespace DBPlatformSpace;
	DataManager* pManager = qobject_cast<DataManager*>(getDataManager());
	ResultMsg rm;
	jsonObj = json::array();
	//获取数据
	list<M_NormalColumnDAO*> headlist;//表头信息
	list<string> valuelist;  // 其它数据
	//组件接口获取数据
	M_EntityTableDAO* pTable = dynamic_cast<M_EntityTableDAO*>(_pDBDAO);
	DataAttribute* pAtt = nullptr;
	
	
	rm = pTable->getData(headlist, valuelist);
	if (rm.rCode != 0 ) 
	{
		if (rm.rMsg != "未查询到数据")
		{
			LOG(INFO) << CommonHelper::utf8ToStdString("getData  failed");
			LOG(INFO) << rm.rMsg;
			return false;
		}
	}
	LOG(INFO) << CommonHelper::utf8ToStdString("getData  success");
	if (valuelist.size() == 0)
	{
		//没有数据
		list<M_NormalColumnDAO*>::iterator it = headlist.begin();
		while (it != headlist.end())
		{
			string item = (*it)->_name;//名称标识
			if (item != "id")
			{
				//调用组件接口重新获取显示字段名 
			//	item = (*it)->_displayName + "_new";  //暂时写给这样测试用
				item = (*it)->NameToDAOAttriName((*it)->_name);
				pAtt = qobject_cast<DataAttribute*>(pManager->findObjectById(DataManager::DataType::dataAttribute, (*it)->_ID));
				pAtt->_displayfield = QString::fromStdString(item);
				colType.insert(pAtt->_displayfield, pAtt->_wDataType);
			}
			it++;
		}
		LOG(INFO) << CommonHelper::utf8ToStdString("getAllDataToJson :  数据类没有数据 !");
		return true;
	}

	list<string>::iterator value_it = valuelist.begin();
	while (value_it != valuelist.end())
	{
		int index = 0; 
		DataRow* pDataCol = new DataRow(); //保存每行数据
		pDataCol->colnum = static_cast<int>(headlist.size());
		QStringList v = CommonHelper::stringToQstring((*value_it)).split("@#@");
		int id = v[0].toInt();//第一个数据 为id

		json j;
		list<M_NormalColumnDAO*>::iterator it = headlist.begin();
		tableData.append(pDataCol);
		while (it != headlist.end())
		{
			string item = (*it)->_name;//名称标识
			if (item != "id")
			{
				//调用组件接口重新获取显示字段名 
			//	item = (*it)->_displayName + "_new";  //暂时写给这样测试用
				item = (*it)->NameToDAOAttriName((*it)->_name);
				pAtt = qobject_cast<DataAttribute*>(pManager->findObjectById(DataManager::DataType::dataAttribute, (*it)->_ID));
				pAtt->_displayfield = QString::fromStdString(item);
				colType.insert(pAtt->_displayfield, pAtt->_wDataType);
			}
		
			//如果是char*和double*的话，需要单独取值
			QString value;
			if ((*it)->_dataType == MNORMALCOL_TYPE_CHARPTR || (*it)->_dataType == MNORMALCOL_TYPE_DOUBLEPTR)
			{
				double* pData = nullptr;
				int size = 0;
				rm = pTable->getBlobData(*it, id, pData, size);
				if (rm.rCode != 0)
				{
					QString msg = "getBlobData  failed.  id = " + QString::number(id);
					LOG(INFO) << CommonHelper::qstringToStdString(msg);
					LOG(INFO) << rm.rMsg;
					return false;
				}
				if (size > 0)
				{
					QByteArray bytes( (char*)pData, size);
					//只返回size
					value = QString("%1 bytes").arg(size);
					//转base64 
				//	value = bytes.toBase64();
				////	QByteArray aa = QByteArray::fromBase64(QString(base64).toLocal8Bit());
				//	QString retValue = QString::fromLocal8Bit(bytes); //输出日志用
				//	QString msg = "getBlobData from DB : " + retValue + ";  id = " + QString::number(id);
				//	LOG(INFO) << CommonHelper::qstringToStdString(msg);
					delete[] pData;
				}
				else {
					//size = 0 空
					LOG(INFO) << "getBlob size = 0";
				//	QByteArray bytes("NULL");
				//	value = bytes.toBase64();
					value = "NULL";
				//	QByteArray aa = QByteArray::fromBase64(QString(value).toLocal8Bit());
				}
			
			}
			else {
				//其它数据类型
				value = v.at(index);

			}
			j[item] = CommonHelper::qstringToUtf8(value);
			pDataCol->colName[index] = QString::fromStdString(item);
			pDataCol->value[index] = value;
			index++;
			it++;
		}
	
		jsonObj.push_back(j);
		value_it++;
	}
	return true;
}

/*20240613 先检查数据合法性，若有类型不符返回相应数据。
逐条保存到数据库，记录保存成功的id, 某条失败或者成功都需要将id发送回前端
*/

bool DataClass::saveTableData(json& jsonObj, DPData* /*pModel*/)
{
	using namespace DBPlatformSpace;
	auto data = jsonObj["data"];
	auto items = data["items"];

	//如果没有数据保存，可直接返回
	if (items.size() == 0)
		return true;
	//返回保存成功后的ids
	json ids = json::array();

	//把 数据存入数据库
	list<M_NormalColumnDAO*> collist;//表头信息
	list<string> valuelist; 

	//测试base64
	//QString aa = "qwe";
	//QByteArray bytes = aa.toLocal8Bit();
	//QString base64 = bytes.toBase64();
	//QByteArray ab = QByteArray::fromBase64(QString(base64).toLocal8Bit());
	//QString str = QString::fromLocal8Bit(ab);

	
	string value;
	//组件接口
	M_EntityTableDAO* pTableDAO = dynamic_cast<M_EntityTableDAO*>(_pDBDAO);
	pTableDAO->getData(collist, valuelist);
	valuelist.clear();

	DataManager* pManager = qobject_cast<DataManager*>( getDataManager());
	int  error = 0; //是否有数值与类型不符合的情况

	list<M_NormalColumnDAO*> collist_to_save;
	//检查数据类型是否有不符合的情况
//	QMap<string, M_NormalColumnDAO*> displayNameToCol ; //显示名----列
	for (auto& kv : items)
	{
		list<M_NormalColumnDAO*>::iterator it = collist.begin();
		for (; it != collist.end(); ++it)
		{
			if ((*it)->_name == "id")
			{
				continue;
			}
			DataAttribute* pAtt = qobject_cast<DataAttribute*>(pManager->findObjectById(DataManager::DataType::dataAttribute, (*it)->_ID));
			string key = CommonHelper::qstringToStdString(pAtt->_displayfield);
			string v = CommonHelper::utf8ToStdString(kv[key]);
		//	displayNameToCol.insert(key, (*it));
			//检查类型是否有误
			if (pAtt->_wDataType == MNORMALCOL_TYPE_INT)
			{
				if (0 == atoi(v.c_str()) && v.size() > 1)
				{
					error += 1;
					QString name = CommonHelper::stringToQstring(v);
					//	QString str = QString("数据项值 \"%1\" 类型错误！").arg(name);
					json j;
					j["column"] = CommonHelper::stringToUtf8(key);
					j["value"] = CommonHelper::stringToUtf8(v);
					jsonObj["response"]["error"].push_back(j);
				}
			}
		}
	}

	if (error > 0)
	{
		return false;
	}
	//2. 逐条保存数据
	//先获取一次数据库中id 
	QMap<int, int> oldIds;

	for (auto& kv : items)
	{
		//非blob数据
		list<M_NormalColumnDAO*> cols_not_blob;
		list<string> vals_not_blob;
		//blob
		list<M_NormalColumnDAO*> cols_blob;
		QList<CHARDataToSave*> Blob_cols_toWrite; //需保存的char*和double*数据
	//	CHARDataToSave* pBlobData = nullptr;
		QString itemVal;
		QStringList qValue; //每行数据
		int id = (CommonHelper::utf8ToQString(kv["id"])).toInt();
		list<M_NormalColumnDAO*>::iterator it = collist.begin();
		for (; it != collist.end(); ++it)
		{
			itemVal = "";
			if ((*it)->_name == "id")
			{
				itemVal = CommonHelper::stringToQstring(kv["id"]);
				cols_not_blob.push_back((*it));
			}
			else
			{
				DataAttribute* pAtt = qobject_cast<DataAttribute*>(pManager->findObjectById(DataManager::DataType::dataAttribute, (*it)->_ID));
				string key = CommonHelper::qstringToStdString(pAtt->_displayfield);
				string v = CommonHelper::utf8ToStdString(kv[key]);
				//blob数据
				int type = pAtt->_wDataType;
				if (type == MNORMALCOL_TYPE_CHARPTR || type == MNORMALCOL_TYPE_DOUBLEPTR)
				{
					cols_blob.push_back(*it);
					CHARDataToSave* pBlobData = new CHARDataToSave();
					pBlobData->pCol = (*it);
					if (kv[key] == "")
					{
						pBlobData->v = "";
					}
					else
					{
						pBlobData->v = CommonHelper::utf8ToQString(kv[key]);
					}

					pBlobData->id = id;
					Blob_cols_toWrite.push_back(pBlobData);
					continue;
				}
				else
				{//非blob数据
					if (v == "")
					{
						//根据属性类型给默认值
						if (type == MNORMALCOL_TYPE_INT) //整型
						{
							itemVal = "0";
						}
						else if (type == MNORMALCOL_TYPE_STRING)//字符型
						{
							itemVal = " ";
						}
						else if (type == MNORMALCOL_TYPE_DOUBLE) //实型
						{
							itemVal = "0.0";
						}
					}
					else {
						itemVal = CommonHelper::stringToQstring(v);
					}
					cols_not_blob.push_back((*it));

				}
			}
			qValue.push_back(itemVal);		
		}
	
		string value = CommonHelper::qstringToStdString(qValue.join("@#@"));
		vals_not_blob.push_back(value);
		//每次保存之前获取一次
		getTableDataIds(pTableDAO, oldIds);
		//保存非blob数据
		ResultMsg rm = pTableDAO->saveData(cols_not_blob, vals_not_blob);
		if (rm.rCode != 0)
		{
			LOG(ERROR) << CommonHelper::utf8ToStdString("DataClass:saveData failed");
			//保存数据失败
			jsonObj["error"] = "保存数据失败";
			jsonObj["response"]["returnIDs"] = ids;
			LOG(ERROR) << rm.rMsg;
			return false;
		}
		else
		{
			if (id == -1)
			{
				int newId = getNewId(pTableDAO, oldIds);
				if (newId != -1)
				{
					ids.push_back(newId);
					id = newId;  //当前新建成功的数据id
				}
			}
			else {
				ids.push_back(id);
			}	
		}
		//保存blob数据

		if (Blob_cols_toWrite.size()>0)
		{
			for (auto clchar : Blob_cols_toWrite)
			{
				if (clchar->v == "")
				{
					delete clchar;
					clchar = nullptr;
					continue;
				}
				int buffsize = 0;
				char* buf = nullptr;
				QByteArray fileData;
			//	QByteArray bytesToWrite = QByteArray::fromBase64(clchar->v.toLocal8Bit());
				
				//if (bytesToWrite != "NULL" && bytesToWrite != "")
				//{
				//	len = bytesToWrite.size();
				//	buf = bytesToWrite.data();
				//}
				if (clchar->v != "NULL")
				{
					//说明选择了文件
					QString filename = clchar->v;
					QFile sFile(filename);
					//以只读方式打开文件（运行到此时，文件已经存在目录中）
					if (!sFile.open(QIODevice::Truncate | QIODevice::ReadOnly))
						printf("Open file failed!\n");
					QByteArray tep = sFile.readAll();
					buffsize = tep.size();
					fileData = QByteArray::fromRawData(tep, tep.size());
					buf = fileData.data();
					sFile.close();
				}
				else
				{
					LOG(INFO) << CommonHelper::utf8ToStdString("DataClass:saveBlobData NULL");
				}

				if (clchar->id == -1)
				{//重新获取id
					clchar->id = id;
				}

			//	QString valuew = QString::fromLocal8Bit(bytesToWrite.toBase64());	
				rm = pTableDAO->saveBlobData(clchar->pCol, (double*)buf, buffsize, clchar->id);

				if (rm.rCode != 0)
				{
					LOG(ERROR) << CommonHelper::utf8ToStdString("DataClass:saveBlobData failed");
					LOG(ERROR) << rm.rMsg;
					//保存数据失败
					jsonObj["error"] = "保存数据失败";
					jsonObj["response"]["returnIDs"] = ids;
					qDeleteAll(Blob_cols_toWrite);
					Blob_cols_toWrite.clear();
					return false;
				}

				delete clchar;
				clchar = nullptr;
				LOG(INFO) << CommonHelper::utf8ToStdString("DataClass:saveBlobData success");
			}
		
		}

	}
	QString tempFilePath = QCoreApplication::applicationDirPath() + "/temp/";
	CommonHelper::deleteFilesInFolder(tempFilePath);
	jsonObj["response"]["returnIDs"] = ids;

	return true;


}

bool DataClass::delTableData(json& jsonObj)
{
	using namespace DBPlatformSpace;
	auto data = jsonObj["data"];
	//组件接口
	M_EntityTableDAO* pTableDAO = dynamic_cast<M_EntityTableDAO*>(_pDBDAO);
	if (data["items"].size() == 0)
	{
		//全删除
		ResultMsg rm = pTableDAO->delAllData();
		if (rm.rCode == 0)
		{
			return true;
		}
		else
		{
			jsonObj["error"] = "删除数据失败！";
			return false;
		}		
	}
	else
	{
		vector<int> ids = data["items"];
		ResultMsg rm = pTableDAO->delData(ids);
		if (rm.rCode == 0)
		{
			return true;
		}
		else
		{
			jsonObj["error"] = "删除数据失败！";
			return false;
		}		
	}

}

int DataClass::filterData(QString filterStr, json& jsonRet)
{
	//tableData.clear();
	////数据
	//for (int i = 0; i < 10000; i++)
	//{
	//	DataRow* pdata = new DataRow();
	//	if (pdata)
	//	{
	//		for (int j = 0; j < 6; j++)
	//		{
	//			double a = (rand() % (10000 - 6000 + 1) + 6000) / 100.0;
	//			pdata->value[j] = QString::number(a);	
	//			
	//		}
	//		tableData.append(pdata);
	//	}	
	//}
	
	opStack.clear();
	QStringList filterStrList = filterStr.split("#");
	for (auto str: filterStrList)
	{
		if (str.split(",").size() > 3)
		{
			int pos = str.lastIndexOf(",");
			opStack.push_back(str.left(pos));
			opStack.push_back(str.right(str.length() - pos - 1));
		}
		else
		{
			opStack.push_back(str);
		}
	}
	
	//表结构()//1 int 2 string 3 double
	//colType.insert("id", 1);
	//colType.insert("proA", 2);
	//colType.insert("proB", 3);
	//colType.insert("proC", 2);
	//colType.insert("proD", 1);
	//colType.insert("proE", 1);
//	colnum = 6;

	//开始筛选
	doFilter(jsonRet);

	return 1;
}

void DataClass::doFilter( json& jsonRet)
{
//	long t1 = clock();
	for (int i = 0; i < tableData.size(); i++)
	{
		QStack tpStack = opStack;
		DataRow* pData = tableData[i];
		while (tpStack.size() > 0)
		{
			QString op = tpStack.pop();
			QStringList str = op.split(",");
			if (str.size() >= 3)
			{
				//说明是判断条件 
				Filter* pFilter = new Filter();	
				pFilter->field = str[0];
				pFilter->condition = str[1];
				pFilter->value = str[2];
				bool b = pFilter->checkRow(pData, getFieldType(pFilter->field));
				midResultStack.push_back(b);
			}
			else
			{
				//说明是连接符 and or
				if (op == "and")
				{ //再取一个出来
					op = tpStack.pop();
					Filter* pFilter = new Filter();
					QStringList str = op.split(",");
					pFilter->field = str[0];
					pFilter->condition = str[1];
					pFilter->value = str[2];
					bool b = pFilter->checkRow(pData, getFieldType(pFilter->field));
					bool last = midResultStack.pop();
					midResultStack.push_back(b && last);
				}
				else
				{
					//or
				}
			}
		}
		//判断该条数据是否满足条件 
		while (midResultStack.size() > 0)
		{//这里面都是or的关系，有一个为 true即为true
			if (midResultStack.pop())
			{
				json j;
				pData->toJson(j);
				jsonRet.push_back(j);
				midResultStack.clear();
				continue;
			}
		}	
	}
	//long t2 = clock();
	//int t = t2 - t1;
}

int DataClass::getFieldType(QString fieldname)
{
	//if (!_initAttriute)
	//	getAllChildren(pDManager);

	//for (auto child : _childrenMap)
	//{
	//	if (QString::compare(fieldname, child->_name) == 0)
	//	{
	//		DataAttribute* pAtt = qobject_cast<DataAttribute*>(child);
	//		return pAtt->_wDataType;
	//	}
	//}
	if (colType.contains(fieldname))
		return colType[fieldname];
	return -1;
}


bool DataClass::generateCode(QStringList& qfileList)
{
	//代码生成路径？生成文件列表？
	using namespace DBPlatformSpace;
	ResultMsg rm;
	SysManager& sysMgr = GetSysManager();
	QString codeFileFolderPath = sysMgr._codeGeneratePath;
	//代码生成路径
	codeFileFolderPath += "/C++/";
	list<string> fileList;
	DataModelData* pModel = qobject_cast<DataModelData*>(getDataModelOwner());
	M_EntityModelDAO* pModelDao = dynamic_cast<M_EntityModelDAO*>(pModel->_pDBDAO);
	M_EntityTableDAO* pTablDao = dynamic_cast<M_EntityTableDAO*>(_pDBDAO);
	rm = pTablDao->CreateCode(pModelDao, CommonHelper::qstringToStdString(codeFileFolderPath), fileList);
	//    pTablDao = dynamic_cast<M_EntityTableDAO*>(_pDBDAO);
	if (rm.rCode == 0)
	{
		for (auto i : fileList)
		{
			qfileList.append(CommonHelper::stringToQstring(i));
		}
		LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.CreateCode   success");
		return true;
	}
	LOG(ERROR) << CommonHelper::utf8ToStdString("DataClass:M_EntityTableDAO.CreateCode   failed");
	LOG(ERROR) << rm.rMsg;
	return false;
}

bool DataClass::generateCSharpCode(QStringList& qfileList)
{
	using namespace DBPlatformSpace;

	CodeGenerator generator;
	SysManager& sysMgr = GetSysManager();
	QString codeFileFolderPath = sysMgr._codeGeneratePath;
	//代码生成路径
	codeFileFolderPath += "/NET/";  
	//当前模型
	DataModelData* pModel = qobject_cast<DataModelData*>(getDataModelOwner());
	M_EntityModelDAO* pModelDao = dynamic_cast<M_EntityModelDAO*>(pModel->_pDBDAO);
	//当前Table
	M_EntityTableDAO* pTablDao = dynamic_cast<M_EntityTableDAO*>(_pDBDAO);

	ResultMsg rm;
	list<string> fileList;
	rm = generator.generateCSharpCode(pTablDao, pModelDao, CommonHelper::qstringToStdString(codeFileFolderPath), fileList);

	if (rm.rCode == 0)
	{
		for (auto i : fileList)
		{
			qfileList.append(CommonHelper::stringToQstring(i));
		}
		LOG(INFO) << CommonHelper::utf8ToStdString("M_EntityTableDAO.generateCSharpCode   success");
		return true;
	}
	else
	{
		LOG(ERROR) << CommonHelper::utf8ToStdString("DataClass:M_EntityTableDAO.generateCSharpCode   failed");
		LOG(ERROR) << rm.rMsg;
		return false;
	}
	
	return true;
}

//bool DataClass::generateHeadfile(QString& filename,QString path)
//{
//	QString fileDao = getCodeFileName();
//	filename = path + fileDao + "Wrapper.h";
//	QFile hfile(filename);
//	if (!hfile.open(QIODevice::WriteOnly | QIODevice::Text)) {
//		return -1;
//	}
//	QString content;
//	content += "#pragma once";
//	content += "\n";
//	content += "#include \"common.h\"\n";
//	content += "#include \"" + fileDao + ".h\"";
//	content += "\n";
//	content += "#include \"DAOWrapper.h\"";
//	content += "\n";
//	content += "using namespace System;\n";
//	content += "using namespace System::Collections::Generic;\n";
//	content += "using namespace DBPlatformSpace;\n";
//	content += "\n";
//	content += "namespace clrDBwrapper { \n";
//	content += QString("	public ref class %1Wrapper:public DAOWrapper\n").arg(fileDao);
//	content += "	{\n";
//	content += "	public:\n";
//	//数据类的属性
//	//同时处理为查找序列的属性生成的FindBy函数
//	for(const auto key:_childrenMap.keys())
//	{
//		DataAttribute* pA = qobject_cast<DataAttribute*>(_childrenMap.value(key));
//		QString type;
//		QString value;
//		string sname = pA->_pDBDAO->_name;
//		QString name = CommonHelper::stringToQstring(DBPlatformSpace::M_NormalColumnDAO::NameToDAOAttriName(sname));
//	
//		if(pA->_wDataType == 1)
//		{//整型
//			type = "int";
//			value = "0";
//		}
//		else if(pA->_wDataType == 2)
//		{//字符型
//			type = "String^";
//			value = "\"\"";
//		}
//		else if(pA->_wDataType == 3)
//		{
//			type = "double";
//			value = "0.0";
//		}
//		content += QString("		%1		%2 = %3;	//%4\n").arg(type).arg(name).arg(value).arg(pA->_strDisplayName);
//		
//		//如果为查找序列
//		if (pA->_wIsFindKey)
//		{
//			ByFunction* pfun = new ByFunction();
//			QString byAttr = name.right(name.size() - 1);
//			QString funcName = "FindBy" + (byAttr[0].toUpper() + byAttr.mid(1));
//
//			pfun->name = funcName;
//			pfun->paraCount = 1;
//			pfun->paraType[0] = pA->_wDataType;
//			pfun->paraName.append(byAttr);
//			QString para = QString("(%1 %2, List<%3Wrapper^>^% pnewlist)").arg(type).arg(byAttr).arg(fileDao);
//			pfun->nameAndParastr = pfun->name + para;
//			_findbyFuncs.append(pfun);
//		}
//	
//	}
//	//构造析构函数
//	content += "\n";
//	content += QString("		%1Wrapper();\n").arg(fileDao);
//	content += QString("		~%1Wrapper();\n").arg(fileDao);
//	//save和delself.delAll
//	content += "\n";
//	content += "		RMWrapper^ save() ;\n";
//	content += "		RMWrapper^ delself() ;\n";
//	content += "        RMWrapper^ delAll() ;\n";
//	
//	//固定查询函数
//	content += "\n";
//	content += QString("		static RMWrapper^ FindAll(List<%1Wrapper^>^% pnewlist);\n").arg(fileDao);
//	content += QString("		static RMWrapper^ FindByID(int id, %1Wrapper^% pnewdao);\n").arg(fileDao);
//
//	////设置的findby函数
//	//_findbyFuncs.clear();
//	//_findbyParas.clear();
//	//查询序列函数
//	for (int i = 0; i < _findbyFuncs.size(); i++)
//	{
//		ByFunction* pf = _findbyFuncs[i];
//		content += QString("		static RMWrapper^ %1;\n").arg(pf->nameAndParastr);
//	}
//	
//	//通过工具设置的接口
//	for (const auto key : _findByMap.keys())
//	{
//		FindByInterface* pFb = qobject_cast<FindByInterface*>(_findByMap.value(key));
//		ByFunction* pfun = new ByFunction();
//		pfun->name = pFb->_name; //函数名
//		QStringList parals = pFb->_paraList.split("#");
//	
//		QStringList funPara;
//		//QStringList callPara;
//
//		for (int i = 0; i< parals.size(); i++)
//		{
//			pfun->paraCount += 1; //参数个数
//			QStringList para = parals[i].split(",");
//			int attId = para.at(0).toInt();  //属性id
//			DataAttribute* pA = qobject_cast<DataAttribute*>(getAttributeById(attId));
//			pfun->paraType[i] = pA->_wDataType;
//			pfun->paraName.append(pA->_name.toLower());
//		
//			//参数
//			if (pA->_wDataType == 1)
//			{
//				funPara.push_back(QString("int %1").arg(pA->_name.toLower()));
//			}
//			else if (pA->_wDataType == 2) //字符型 
//			{
//				funPara.push_back(QString("String^ %1").arg(pA->_name.toLower()));
//			}
//			else if (pA->_wDataType == 3)
//			{
//				funPara.push_back(QString("double %1").arg(pA->_name.toLower()));
//			}
//		} 
//		funPara.push_back(QString("List<%1Wrapper^>^% pnewlist").arg(fileDao));
//		//函数名
//		content += "\n";
//		QString para = QString("(%2)").arg(funPara.join(", "));
//		pfun->nameAndParastr = pfun->name + para;
//		_findbyFuncs.append(pfun);
//	//	content += QString("		static RMWrapper %1(%2);\n").arg(funName).arg(funPara.join(", "));
//		content += QString("		static RMWrapper^ %1;\n").arg(pfun->nameAndParastr);
//	//	_findbyFuncs.append(funcName);
//	//	_findbyParas.append(callPara.join(", "));
//	}
//
//	//设置的delby函数
////	_delbyFuncs.clear();
////	_delbyParas.clear();
//	for (const auto key : _delByMap.keys())
//	{
//		DelByInterface* pDb = qobject_cast<DelByInterface*>(_delByMap.value(key));
//		ByFunction* pfun = new ByFunction();
//		pfun->name = pDb->_name; //函数名
//		QStringList parals = pDb->_paraList.split("#");
//	//	QString funName = "DelBy";
//		QStringList funPara;
//	//	QStringList callPara;
//		for (int i = 0; i < parals.size(); i++)
//		{
//			pfun->paraCount += 1;
//			QStringList para = parals[i].split(",");
//			int attId = para.at(0).toInt();  //属性id
//			DataAttribute* pA = qobject_cast<DataAttribute*>(getAttributeById(attId));
//			pfun->paraType[i] = pA->_wDataType;
//			pfun->paraName.append(pA->_name.toLower());
//		
//			//参数
//			if (pA->_wDataType == 1)
//			{
//				funPara.push_back(QString("int %1").arg(pA->_name.toLower()));
//			}
//			else if (pA->_wDataType == 2) //字符型 
//			{
//				funPara.push_back(QString("String^ %1").arg(pA->_name.toLower()));
//			}
//			else if (pA->_wDataType == 3)
//			{
//				funPara.push_back(QString("double %1").arg(pA->_name.toLower()));
//			}
//			
//		}
//		//函数名
//		content += "\n";
//		QString para = QString("(%1)").arg(funPara.join(", "));;
//		pfun->nameAndParastr = pfun->name + para;
//		content += QString("		static RMWrapper^ %1;\n").arg(pfun->nameAndParastr);
//		//_delbyFuncs.append(funcname);
//		//_delbyParas.append(callPara.join(", "));
//	}
//		
//	//私有dao成员
//	content += "\n";
//	content += "	public:\n";
//	content += QString("		void load();\n");
//	content += QString("		void savetoDao();\n");
//	content += QString("		%1*		_pdao = NULL;\n").arg(fileDao);
//
//	content += "	};\n";
//	content += "}\n";
//
//	hfile.write(content.toStdString().c_str());
//	hfile.close();
//
//
//	return true;
//}
//
//bool DataClass::generateSrcfile(QString& filename, QString path)
//{
//	//.cpp文件
//	QString fileDao = getCodeFileName();
//	filename = path + fileDao + "Wrapper.cpp";
//	QFile srcFile(filename);
//	if (!srcFile.open(QIODevice::WriteOnly | QIODevice::Text)) {
//		return -1;
//	}
//	QString content;
//	content += QString("#include \"%1Wrapper.h\"\n").arg(fileDao);
//	content += QString("#include \"templateFun.h\"\n");
//	content += "using namespace System::Runtime::InteropServices;\n";
//	content += "using namespace clrDBwrapper;\n";
//	//构造函数
//	content += "\n";
//	content += QString("%1Wrapper::%2Wrapper()\n").arg(fileDao).arg(fileDao);
//	content += "{\n";
//	content += "}\n";
//	//析构函数
//	content += "\n";
//	content += "\n";
//	content += QString("%1Wrapper::~%2Wrapper()\n").arg(fileDao).arg(fileDao);
//	content += "{\n";
//	content += "	if (_pdao)\n";
//	content += "	{\n";
//	content += QString("		delete _pdao;\n");
//	content += QString("		_pdao = NULL;\n");
//	content += "	}\n";
//	content += "}\n";
//	//固定find函数
//	//findAll
//	content += "\n";
//	content += QString("RMWrapper^  %1Wrapper::FindAll(List<%2Wrapper^>^% pnewlist)\n").arg(fileDao).arg(fileDao);
//	content += "{\n";
//	content += QString("	list<%1*> daolist;\n").arg(fileDao);
//	content += QString("	ResultMsg rm = %1::FindAll(daolist);\n").arg(fileDao);
//	content += QString("	copydaolistT<%1,%2Wrapper>(daolist, pnewlist);\n").arg(fileDao).arg(fileDao);
//	content += QString("	RMWrapper^ ret = gcnew RMWrapper(rm.rCode, rm.rMsg);\n");
//	content += QString("	return ret;\n");
//	content += "}\n";
//	//findbyID
//	content += "\n";
//	content += QString("RMWrapper^ %1Wrapper::FindByID(int id, %2Wrapper^% pnewdao)\n").arg(fileDao).arg(fileDao);
//	content += "{\n";
//	content += QString("	return findbyIdT<%1,%2Wrapper>(id,pnewdao);\n").arg(fileDao).arg(fileDao);
//	content += "}\n";
//	//生成save/delself/delall函数
//	generateSaveDelselfFunc(content);
//	//设置的findby函数
//	generateFindbyFunction(content);
//	//设置的delby函数
//	generateDelbyFunction(content);
//	//生成load函数
//	generateLoadFunc(content);
//	//生成savetoDao函数
//	generateSavetoDaoFunc(content);
//
//	srcFile.write(content.toStdString().c_str());
//	srcFile.close();
//
//	return true;
//}
//
//void DataClass::generateFindbyFunction(QString& content)
//{
//	QString fileDao = getCodeFileName();
//
//	for (int i = 0; i < _findbyFuncs.size(); i++)
//	{
//		content += "\n";
//		ByFunction *pf = _findbyFuncs[i];
//		content += QString("RMWrapper^ %1Wrapper::%2\n").arg(fileDao).arg(pf->nameAndParastr);
//		content += "{\n";
//		content += QString("	list<%1*> daolist;\n").arg(fileDao);
//		//如果参数中有string类型，需要转换
//		QStringList callpara;//调用参数字符串
//		for (int i = 0; i < pf->paraCount; i++)
//		{
//			QString namestring = pf->paraName[i];
//			if (pf->paraType[i] == 2) //字符串
//			{
//				namestring = QString("str%1").arg(pf->paraName[i]);
//				content += QString("	string %1 = (char*)(Marshal::StringToHGlobalAnsi(%2)).ToPointer();\n").arg(namestring).arg(pf->paraName[i]);
//			}
//			callpara.append(namestring);
//		}
//		//findby参数
//		content += QString("	ResultMsg rm = %1::%2(%3,daolist);\n").arg(fileDao).arg(pf->name).arg(callpara.join(","));
//	
//		content += QString("	copydaolistT<%1,%2Wrapper>(daolist, pnewlist);\n").arg(fileDao).arg(fileDao);
//		content += QString("	RMWrapper^ ret = gcnew RMWrapper(rm.rCode, rm.rMsg);\n");
//		content += QString("	return ret;\n");
//		content += "}\n";
//	}
//
//}
//
//void DataClass::generateDelbyFunction(QString& content)
//{
//	//QString fileDao = getCodeFileName();
//	//for (int i = 0; i < _delbyFuncs.size(); i++)
//	//{
//	//	content += "\n";
//	//	content += QString("RMWrapper^ %1Wrapper::%2\n").arg(fileDao).arg(_delbyFuncs[i]);
//	//	content += "{\n";
//	//	int pos = _delbyFuncs[i].indexOf("(");
//	//	QString func = _delbyFuncs[i].left(pos);
//	//	content += QString("	ResultMsg rm = %1::%2(%3);\n").arg(fileDao).arg(func).arg(_delbyParas[i]);
//	//	content += QString("	RMWrapper^ ret = gcnew RMWrapper(rm.rCode, rm.rMsg);\n");
//	//	content += QString("	return ret;\n");
//	//	content += "}\n";
//	//}
//}
//
//
//DPData* DataClass::getAttributeById(int id)
//{
//	for (const auto key : _childrenMap.keys())
//	{
//		if (_childrenMap.value(key)->_id == id)
//			return _childrenMap.value(key);
//	}
//	return nullptr;
//}
//
////生成load函数
//void DataClass::generateLoadFunc(QString&  content)
//{
//	content += "\n";
//	QString fileDao = getCodeFileName();
//	content += QString("void %1Wrapper::load()\n").arg(fileDao);
//	content += "{\n";
//	content += QString("	_id = _pdao->_ID;\n");
//	for (const auto key : _childrenMap.keys())
//	{
//		DataAttribute* pA = qobject_cast<DataAttribute*>(_childrenMap.value(key));
//		string sname = pA->_pDBDAO->_name;
//		QString name = CommonHelper::stringToQstring(DBPlatformSpace::M_NormalColumnDAO::NameToDAOAttriName(sname));
//		if (pA->_wDataType == 2)
//		{
//			//字符串
//			content += QString("	%1 = gcnew String(_pdao->%2.c_str());\n").arg(name).arg(name);
//		}
//		else
//		{
//			content += QString("	%1 = _pdao->%2;\n").arg(name).arg(name);
//		}
//	}
//	content += "}\n";
//}
////生成savetoDao函数
//void DataClass::generateSavetoDaoFunc(QString& content)
//{
//	content += "\n";
//	QString fileDao = getCodeFileName();
//	content += QString("void %1Wrapper::savetoDao()\n").arg(fileDao);
//	content += "{\n";
//
//	for (const auto key : _childrenMap.keys())
//	{
//		DataAttribute* pA = qobject_cast<DataAttribute*>(_childrenMap.value(key));
//		string sname = pA->_pDBDAO->_name;
//		QString name = CommonHelper::stringToQstring(DBPlatformSpace::M_NormalColumnDAO::NameToDAOAttriName(sname));
//		if (pA->_wDataType == 2)
//		{
//			//字符串
//			content += QString("	_pdao->%1 = (char*)(Marshal::StringToHGlobalAnsi(%2)).ToPointer();\n").arg(name).arg(name);
//		}
//		else
//		{
//			content += QString("	_pdao->%1 = this->%2;\n").arg(name).arg(name);
//		}
//	}
//
//	content += "}\n";
//}
//
//void DataClass::generateSaveDelselfFunc(QString& content)
//{
//	QString fileDao = getCodeFileName();
//	content += "\n";
//	//save
//	content += QString("RMWrapper^ %1Wrapper::save()\n").arg(fileDao);
//	content += "{\n";
//	content += "	if( !_pdao )\n";
//	content += "	{\n";
//	content += QString("		_pdao = new %1();\n").arg(fileDao);
//	content += "	}\n";
//	//for (const auto key : _childrenMap.keys())
//	//{
//	//	DataAttribute* pA = qobject_cast<DataAttribute*>(_childrenMap.value(key));
//	//	if (pA->_wDataType == 2)
//	//	{
//	//		//字符串
//	//		content += QString("	_pdao->_%1 = (char*)(Marshal::StringToHGlobalAnsi(_%3)).ToPointer();\n").arg(pA->_name.at(1).toLower() + pA->_name.right(pA->_name.size() - 2)).arg(pA->_name.at(1).toLower() + pA->_name.right(pA->_name.size() - 2));
//	//	}
//	//	else
//	//	{
//	//		content += QString("	_pdao->_%1 = this->_%2;\n").arg(pA->_name.at(1).toLower() + pA->_name.right(pA->_name.size() - 2)).arg(pA->_name.at(1).toLower() + pA->_name.right(pA->_name.size() - 2));
//	//	}
//	//}
//	content += QString("	return saveT<%1,%2Wrapper>(_pdao, this);\n").arg(fileDao).arg(fileDao);
//	content += "}\n";
//
//	//delself
//	content += "\n";
//	content += QString("RMWrapper^ %1Wrapper::delself()\n").arg(fileDao);
//	content += "{\n";
//	content += QString("	return delselfT(_pdao);\n");
//	content += "}\n";
//	//delall
//	content += "\n";
//	content += QString("RMWrapper^ %1Wrapper::delAll()\n").arg(fileDao);
//	content += "{\n";
//	content += QString("	return delAllT(_pdao);\n");
//	content += "}\n";
//
//}