592 lines
18 KiB
C++
592 lines
18 KiB
C++
#ifndef CCSDATABIND_H
|
|
#define CCSDATABIND_H
|
|
#include <QList>
|
|
#include <QMetaProperty>
|
|
#include "reportdataset.h"
|
|
|
|
#if(QT_VERSION_MAJOR == 6)
|
|
#include<QRegularExpression>
|
|
#endif
|
|
namespace CCS_Report {
|
|
//extern QHash<QString,QList<QObject*>> DataSets;
|
|
|
|
class CCSDataBind
|
|
{
|
|
public:
|
|
|
|
static QString bingdataT(QString bindSource,QList<QPair<QString,QString>> filter)
|
|
{
|
|
if (IsDataSourceField(bindSource))
|
|
{
|
|
QPair<QString,QString> pairField = ParserField(bindSource);
|
|
auto find_index = DataSets.find(pairField.first);
|
|
QList<QObject*> a = DataSets[pairField.first];
|
|
if(find_index != DataSets.end())
|
|
{
|
|
foreach (QObject* item ,find_index.value())
|
|
{
|
|
if (Filter(item,filter))
|
|
{
|
|
int index = item->metaObject()->indexOfProperty(pairField.second.toStdString().c_str());
|
|
if (index >=0)
|
|
{
|
|
QMetaProperty metaProp = item->metaObject()->property(index);
|
|
return metaProp.read(item).toString();
|
|
/*QString strValue = metaProp.read(item).toString();
|
|
qDebug() << strValue.isEmpty() << strValue.isNull();
|
|
return strValue;*/
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
/*
|
|
* 实现简单的动态表格，根据表和字段获取某个字段下的多条记录，
|
|
*/
|
|
template<typename T>
|
|
static QList<QString> bingdataDataset(QString bindSource,QList<T*> t,QPair<QString,QString> key)
|
|
{
|
|
QList<QString> listRtn;
|
|
if (IsDataSourceField(bindSource))
|
|
{
|
|
QList<QString> listName = ParserField(bindSource);
|
|
|
|
foreach (T* item,t) {
|
|
int index = item->metaObject()->indexOfProperty(listName[1].toStdString().c_str());
|
|
if (index >=0)
|
|
{
|
|
if (key.first != "")
|
|
{
|
|
int index1 = item->metaObject()->indexOfProperty(key.first.toStdString().c_str());
|
|
if (index1 >=0)
|
|
{
|
|
QMetaProperty metaProp1 = item->metaObject()->property(index1);
|
|
QString strCmp = metaProp1.read(item).toString();
|
|
if (!(strCmp == key.second))
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
QMetaProperty metaProp = item->metaObject()->property(index);
|
|
listRtn.append(metaProp.read(item).toString());
|
|
}
|
|
}
|
|
}
|
|
return listRtn;
|
|
}
|
|
|
|
static bool IsDataSourceField(QString fieldS)
|
|
{
|
|
#if(QT_VERSION_MAJOR == 6)
|
|
QRegularExpression rx("\\$[F]\\{*.*\\}");
|
|
QRegularExpressionMatch match = rx.match(fieldS);
|
|
if (match.hasMatch())
|
|
{
|
|
return true;
|
|
}
|
|
#else
|
|
QRegExp rx("\\$[F]\\{*.*\\}");
|
|
int rtn = rx.indexIn(fieldS);
|
|
if (rtn >= 0)
|
|
{
|
|
return true;
|
|
}
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
static bool IsKeyField(QString fieldS)
|
|
{
|
|
#if(QT_VERSION_MAJOR == 6)
|
|
QRegularExpression rx("\\$[D]\\{.*\\}");
|
|
QRegularExpressionMatch match = rx.match(fieldS);
|
|
if (match.hasMatch())
|
|
{
|
|
return true;
|
|
}
|
|
#else
|
|
QRegExp rx("\\$[D]\\{.*\\}");
|
|
int rtn = rx.indexIn(fieldS);
|
|
if (rtn >= 0)
|
|
{
|
|
return true;
|
|
}
|
|
#endif
|
|
return false;
|
|
}
|
|
static QString ParserKeyField(QString KeyString,int& iStart,int& iEnd)
|
|
{
|
|
QString left = "{";
|
|
QString right = "}";
|
|
QString field = "";
|
|
|
|
iStart = KeyString.indexOf(left);
|
|
iEnd = KeyString.indexOf(right);
|
|
if ((iStart > 0) && (iEnd >0) && (iEnd > iStart))
|
|
{
|
|
field = KeyString.mid(iStart+1,iEnd-iStart-1);
|
|
}
|
|
|
|
return field;
|
|
}
|
|
static void ParserKeyFields(QString KeyString,QList<QString>&listFields, QList<QPair<int,int>>& listPostion)
|
|
{
|
|
QString left = "{";
|
|
QString right = "}";
|
|
QString strValue = KeyString;
|
|
|
|
int iInialEnd = 0;
|
|
while (true)
|
|
{
|
|
int iStart = strValue.indexOf(left);
|
|
int iEnd = strValue.indexOf(right);
|
|
if ((iStart > 0) && (iEnd > 0) && (iEnd > iStart))
|
|
{
|
|
QString field = strValue.mid(iStart + 1, iEnd - iStart - 1);
|
|
if (field.length() > 0)
|
|
{
|
|
QPair<int, int> pairPositon;
|
|
pairPositon.first = iStart + iInialEnd; pairPositon.second = iEnd+iInialEnd;
|
|
listPostion.append(pairPositon);
|
|
listFields.append(field);
|
|
iInialEnd += iEnd + 1;
|
|
}
|
|
strValue = strValue.mid(iEnd+1);
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
static QPair<QString,QString> ParserField(QString fieldS)
|
|
{
|
|
QPair<QString,QString> pairFieldInfo;
|
|
QString left = "{";
|
|
QString right = "}";
|
|
|
|
int first = fieldS.indexOf(left);
|
|
int end = fieldS.indexOf(right);
|
|
//if ((first + 1) > (end - first - 1))
|
|
//{
|
|
// int i=0;
|
|
//}
|
|
QString field = fieldS.mid(first+1,end-first-1);
|
|
int dot = field.indexOf(".");
|
|
if (dot > 0){
|
|
pairFieldInfo.first = field.mid(0,dot);
|
|
pairFieldInfo.second = field.mid(dot+1);
|
|
}
|
|
return pairFieldInfo;
|
|
}
|
|
template<typename T>
|
|
static bool Filter(T* item,QList<QPair<QString,QString>>& filter)
|
|
{
|
|
bool bRecord = true;
|
|
for(int i=0;i<filter.count();i++){
|
|
QPair<QString,QString> pairfilter = filter.at(i);
|
|
int index = item->metaObject()->indexOfProperty(pairfilter.first.toStdString().c_str());
|
|
if (index >=0)
|
|
{
|
|
QMetaProperty metaProp = item->metaObject()->property(index);
|
|
QString strMatchValue =metaProp.read(item).toString();
|
|
if (strMatchValue != pairfilter.second)
|
|
{
|
|
bRecord = false;
|
|
break;
|
|
}
|
|
}else{
|
|
bRecord = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return bRecord;
|
|
}
|
|
|
|
template<typename T>
|
|
static QList<QString> GroupByT(QString field,QList<T*> t,QList<QPair<QString,QString>> filter)
|
|
{
|
|
QList<QString> listRtn;
|
|
QHash<QString,int> hashValue;
|
|
bool bRecord;
|
|
|
|
foreach (T* item, t) {
|
|
bRecord = Filter(item,filter);
|
|
if (bRecord)
|
|
{
|
|
int index = item->metaObject()->indexOfProperty(field.toStdString().c_str());
|
|
if (index >=0)
|
|
{
|
|
QMetaProperty metaProp = item->metaObject()->property(index);
|
|
QString tmp = metaProp.read(item).toString();
|
|
|
|
if (!(hashValue.contains(tmp)))
|
|
{
|
|
|
|
listRtn.append(tmp);
|
|
hashValue.insert(tmp,0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return listRtn;
|
|
}
|
|
template<typename T>
|
|
static QList<QStringList> GroupByT(QStringList field, QList<T*> t, QList<QPair<QString, QString>> filter)
|
|
{
|
|
QList<QStringList> listRtn;
|
|
QList<QString> listFieldValue;
|
|
QHash<QString, int> hashValue;
|
|
bool bRecord;
|
|
QString strValue = "";
|
|
QList<int> listIndex;
|
|
QStringList listValue;
|
|
|
|
foreach(T * item, t) {
|
|
bRecord = Filter(item, filter);
|
|
if (bRecord)
|
|
{
|
|
strValue = "";
|
|
listValue.clear();
|
|
listIndex.clear();
|
|
for (auto f : field)
|
|
{
|
|
int index = item->metaObject()->indexOfProperty(f.toStdString().c_str());
|
|
if (index >= 0)
|
|
{
|
|
listIndex.append(index);
|
|
QMetaProperty metaProp = item->metaObject()->property(index);
|
|
QString strValue1 = metaProp.read(item).toString();
|
|
strValue += strValue1;
|
|
strValue += ",";
|
|
listValue.append(strValue1);
|
|
}
|
|
}
|
|
if (listIndex.count() != field.count())
|
|
continue;
|
|
|
|
if ((!listFieldValue.contains(strValue)))
|
|
{
|
|
listFieldValue.append(strValue);
|
|
listRtn.append(listValue);
|
|
}
|
|
}
|
|
}
|
|
return listRtn;
|
|
}
|
|
//此方法实现动态列的数据，从三维变成二维展示的过程
|
|
/*
|
|
* A B C D A B c1 c2 c3
|
|
* a1 b1 c1 d1 a1 b1 d1 d2 d3
|
|
* a1 b1 c2 d2 ====>
|
|
* a1 b1 c3 d3
|
|
*
|
|
*/
|
|
|
|
///
|
|
/// dynamicField 动态表头列 dynamicValue动态内容列 dyanmicValue非动态列 t 表 key groupID
|
|
///
|
|
template<typename T>
|
|
static QMap<QString,QMap<QString,QString>> TransDynamicColumnDataT(QString dynamicField,QString dynamicValue,
|
|
QList<QString> noDynamicField,QList<T*> t,QList<QPair<QString,QString>> filter)
|
|
{
|
|
//if (transField == "" || varField =="") return NULL;
|
|
|
|
int iCount = 1;
|
|
QString compareRecord;
|
|
QString tranField;
|
|
QString value;
|
|
QHash<QString,QString> hashRecordIdentify;
|
|
QMap<QString,QMap<QString,QString>> listTranslatedData;
|
|
|
|
QString strRecordIdentify =GetFormatName(iCount++,5); //考虑QMap中的排序的问题
|
|
|
|
foreach (T* item, t) {
|
|
bool bRecord = Filter(item,filter);
|
|
if (!(bRecord))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
tranField="";
|
|
value="";
|
|
compareRecord="";
|
|
QMap<QString,QString> hashRecord;
|
|
for (int i = 0; i < item->metaObject()->propertyCount(); ++i) {
|
|
QMetaProperty metaProp = item->metaObject()->property(i);
|
|
QString strField = metaProp.name(); //字段名
|
|
QString strValue = metaProp.read(item).toString(); //字段值
|
|
//判断此字段是否在非动态内容中
|
|
if (noDynamicField.contains(strField))
|
|
{
|
|
//判断非动态行中是否有此记录，作为唯一标识
|
|
if (!(hashRecord.contains(strField)))
|
|
{
|
|
hashRecord.insert(strField,strValue);
|
|
compareRecord += strValue+"&";
|
|
}
|
|
}else if (strField==dynamicField)
|
|
{
|
|
//因为不能确定哪个字段先出现，所以先获取此值，等读取完这条记录后，才进行确定
|
|
tranField = strValue;
|
|
}else if (strField==dynamicValue)
|
|
{
|
|
value = strValue;
|
|
}
|
|
}
|
|
|
|
if (!(hashRecord.contains(tranField)))
|
|
{
|
|
hashRecord.insert(tranField,value);
|
|
}
|
|
if (!(hashRecordIdentify.contains(compareRecord)))
|
|
{
|
|
hashRecordIdentify.insert(compareRecord,strRecordIdentify);
|
|
strRecordIdentify =GetFormatName(iCount++,5);
|
|
}
|
|
|
|
QString strKey = strRecordIdentify+compareRecord;
|
|
if (listTranslatedData.contains(strKey))
|
|
{
|
|
listTranslatedData[strKey].insert(tranField,value);
|
|
}else
|
|
{
|
|
listTranslatedData.insert(strKey,hashRecord);
|
|
}
|
|
}
|
|
return listTranslatedData;
|
|
}
|
|
///
|
|
/// 根据父表的键值获取对应子表的数据
|
|
///
|
|
template<typename T>
|
|
static QList<T*> ChildrenDataByParent(QList<QPair<QString,QString>> listParent,QList<T*> t,QList<QPair<QString,QString>> filter)
|
|
{
|
|
QList<T*> listFilterData;
|
|
bool bFlag = true;
|
|
QList<QPair<QString,QString>> listFilter;
|
|
listFilter = listParent;
|
|
listFilter.append(filter);
|
|
foreach (T* item,t) {
|
|
bFlag = Filter(item,listFilter);
|
|
|
|
if (bFlag)
|
|
{
|
|
//有对应的记录
|
|
listFilterData.append(item);
|
|
}
|
|
}
|
|
return listFilterData;
|
|
}
|
|
template<typename T>
|
|
static QMap<int,QList<T*>> ChildrenDataByParent(QList<QString> listParentValue,QString subKey, QList<T*> t, QList<QPair<QString, QString>> filter)
|
|
{
|
|
QMap<int, QList<T*>> mapSubData;
|
|
QList<QPair<QString, QString>> listKeyValues;
|
|
QPair<QString, QString> pairKeyValue;
|
|
for(int i=0;i<listParentValue.count();i++)
|
|
{
|
|
listKeyValues.clear();
|
|
|
|
pairKeyValue.first = subKey;
|
|
pairKeyValue.second = listParentValue.at(i);
|
|
listKeyValues.append(pairKeyValue);
|
|
|
|
QList<QObject*> listSubTableData = ChildrenDataByParent(listKeyValues, t, filter);
|
|
mapSubData.insert(i, listSubTableData);
|
|
}
|
|
return mapSubData;
|
|
}
|
|
template<typename T>
|
|
static QMap<int, QList<T*>> ChildrenDataByParent(QList<QList<QString>> listParentValue, QList<QString> subKey, QList<T*> t, QList<QPair<QString, QString>> filter)
|
|
{
|
|
QMap<int, QList<T*>> mapSubData;
|
|
QList<QPair<QString, QString>> listKeyValues;
|
|
QPair<QString, QString> pairKeyValue;
|
|
for(int i=0;i<listParentValue.count();i++)
|
|
{
|
|
listKeyValues.clear();
|
|
for (int j = 0; j < listParentValue.at(i).count(); j++)
|
|
{
|
|
pairKeyValue.first = subKey.at(j);
|
|
pairKeyValue.second = listParentValue.at(i).at(j);
|
|
listKeyValues.append(pairKeyValue);
|
|
}
|
|
QList<QObject*> listSubTableData = ChildrenDataByParent(listKeyValues, t, filter);
|
|
mapSubData.insert(i, listSubTableData);
|
|
}
|
|
|
|
return mapSubData;
|
|
}
|
|
|
|
///
|
|
/// 根据父表的键值获取对应子表的数据
|
|
///
|
|
template<typename T>
|
|
static int GetRecordNum(QList<T*> t,QPair<QString,QString> key)
|
|
{
|
|
int iCount = 0;
|
|
if (key.first == "")
|
|
{
|
|
return t.count();
|
|
}
|
|
foreach (T* item,t) {
|
|
int index = item->metaObject()->indexOfProperty(key.first.toStdString().c_str());
|
|
if (index >=0)
|
|
{
|
|
QMetaProperty metaProp = item->metaObject()->property(index);
|
|
QString strValue = metaProp.read(item).toString();
|
|
if ((strValue == key.second))
|
|
{
|
|
iCount++;
|
|
}
|
|
}
|
|
}
|
|
return iCount;
|
|
}
|
|
|
|
|
|
static QString GetFormatName(int num,int digital)
|
|
{
|
|
QString format= "%0"+QString::number(digital)+"d";
|
|
#if(QT_VERSION_MAJOR == 6)
|
|
QString strFormat = QString::number(num).asprintf(format.toStdString().c_str(), num); //考虑QMap中的排序的问题
|
|
return strFormat;
|
|
#else
|
|
QString strFormat = QString::number(num).sprintf(format.toStdString().c_str(), num); //考虑QMap中的排序的问题
|
|
return strFormat;
|
|
#endif
|
|
}
|
|
template<typename T>
|
|
static bool BelongRecord(T* item,QPair<QString,QString> key)
|
|
{
|
|
QString strMatchValue ;
|
|
if (key.first != "")
|
|
{
|
|
int iMatchindex = item->metaObject()->indexOfProperty(key.first.toStdString().c_str());
|
|
if (iMatchindex >=0)
|
|
{
|
|
QMetaProperty metaProp = item->metaObject()->property(iMatchindex);
|
|
strMatchValue = metaProp.read(item).toString();
|
|
if (!(strMatchValue == key.second))
|
|
{
|
|
return false;
|
|
}
|
|
}else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
template<typename T>
|
|
static QList<T*> FilterDataT(QList<T*> t,QList<QPair<QString,QString>> filter)
|
|
{
|
|
QList<T*> filteredTable;
|
|
bool bRecord;
|
|
if (filter.count() == 0) return t;
|
|
|
|
foreach (T* item,t) {
|
|
bRecord = Filter(item,filter);
|
|
|
|
if (bRecord)
|
|
{
|
|
filteredTable.append(item);
|
|
}
|
|
}
|
|
return filteredTable;
|
|
}
|
|
//template<typename T>
|
|
//static QList<QString> GetDataByFieldT(QList<T*> t,QString field,QList<QPair<QString,QString>> filter)
|
|
//{
|
|
// QList<QString> fieldValue;
|
|
// bool bRecord;
|
|
// foreach (T* item,t) {
|
|
// bRecord = true;
|
|
// foreach (QPair<QString,QString> item1, filter) {
|
|
// int index = item->metaObject()->indexOfProperty(item1.first.toStdString().c_str());
|
|
// if (index >=0)
|
|
// {
|
|
// QMetaProperty metaProp = item->metaObject()->property(index);
|
|
// QString strMatchValue =metaProp.read(item).toString();
|
|
// if (strMatchValue != item1.second)
|
|
// {
|
|
// bRecord = false;
|
|
// }
|
|
// }else{bRecord = false;}
|
|
// }
|
|
// if (bRecord)
|
|
// {
|
|
// int index = item->metaObject()->indexOfProperty(field.toStdString().c_str());
|
|
// if (index >=0)
|
|
// {
|
|
// QMetaProperty metaProp = item->metaObject()->property(index);
|
|
// QString strValue =metaProp.read(item).toString();
|
|
// fieldValue.append(strValue);
|
|
// }
|
|
// }
|
|
// }
|
|
// return fieldValue;
|
|
//}
|
|
template<typename T>
|
|
static QList<QString> GetDataByFieldT(QList<T*> t,QString field)
|
|
{
|
|
QList<QString> fieldValue;
|
|
foreach (T* item,t) {
|
|
QString strValue = GetValueByFieldT(item,field);
|
|
fieldValue.append(strValue);
|
|
}
|
|
return fieldValue;
|
|
}
|
|
template<typename T>
|
|
static QString GetValueByFieldT(T* item,QString field)
|
|
{
|
|
QString fieldValue="";
|
|
int index = item->metaObject()->indexOfProperty(field.toStdString().c_str());
|
|
if (index >=0)
|
|
{
|
|
QMetaProperty metaProp = item->metaObject()->property(index);
|
|
fieldValue =metaProp.read(item).toString();
|
|
}
|
|
return fieldValue;
|
|
}
|
|
template<typename T>
|
|
static QList<QList<QString>> GetDataByFieldT(QList<T*> t, QList<QString> fields)
|
|
{
|
|
QList<QList<QString>> fieldValues;
|
|
foreach(T * item, t) {
|
|
|
|
QList<QString> listValues = GetValueByFieldT(item, fields);
|
|
if (listValues.count() > 0)
|
|
fieldValues.append(GetValueByFieldT(item, fields));
|
|
}
|
|
return fieldValues;
|
|
}
|
|
template<typename T>
|
|
static QList<QString> GetValueByFieldT(T* item, QList<QString> fields)
|
|
{
|
|
QList<QString> listFieldValue;
|
|
QList<int> listIndex;
|
|
for (auto o : fields)
|
|
{
|
|
int index = item->metaObject()->indexOfProperty(o.toStdString().c_str());
|
|
if (index <= 0) return listFieldValue;
|
|
listIndex.append(index);
|
|
}
|
|
for (auto o : listIndex)
|
|
{
|
|
QMetaProperty metaProp = item->metaObject()->property(o);
|
|
listFieldValue.append(metaProp.read(item).toString());
|
|
}
|
|
return listFieldValue;
|
|
}
|
|
};
|
|
}
|
|
#endif // CCSDATABIND_H
|