2514 lines
68 KiB
C++
2514 lines
68 KiB
C++
#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";
|
||
//
|
||
//}
|