resistancemonitor/10. tools/HJHWExport/HJHWExport/MonitorObject.cpp

#include "stdafx.h"
#include "MonitorObject.h"
#include <sstream>
#include <ODBC/DBConnectPool.h>
#include <Simplelog.h>
#include <assert.h>
#include "Device.h"
#include <ZlDataDefine.h>

using namespace std;

CMonitorObject::CMonitorObject()
{
}


CMonitorObject::~CMonitorObject()
{
	check = 0x00;
	for (auto& it : m_lstMo)
	{
		delete it;
		it = nullptr;
	}
	m_lstMo.clear();
}

CMonitorObjectMng::CMonitorObjectMng()
{
	Clear();
}

CMonitorObjectMng::~CMonitorObjectMng()
{
	if (m_treeroot) delete m_treeroot;
	m_treeroot = nullptr;
	m_mapImeiIdxMoMp.clear();
	m_mapMoMpImeiIdx.clear();
}

BOOL CMonitorObjectMng::LoadMoMap()
{
	char mo[50];
	char mp[50];
	char imei[50];
	char name1[20];
	char name2[20];
	char name3[20];
	char direct1[20];
	char direct2[20];
	short idx;
	int  zzj_no = 0;
	int epos = 0;
	uint8_t binstall_1 = 0;
	uint8_t binstall_2 = 0;
	uint8_t binstall_3 = 0;

	//CString sql = "SELECT mo,mp,ISNULL(IMEI, ''),ISNULL(idx, 0),ISNULL(zl_1_loca, ''),ISNULL(zl_2_loca, ''), '转换阻力曲线',ISNULL(direct1, ''),ISNULL(direct2, ''),zzjno,epos,install_1,install_2,install_3 FROM rm_map";
	CString sql = "SELECT mo,mp,ISNULL(IMEI, ''),ISNULL(idx, 0),ISNULL(zl_1_loca, ''),ISNULL(zl_2_loca, ''), '转换阻力曲线',ISNULL(direct1, ''),ISNULL(direct2, '') FROM rm_map";

	COdbcStatement stmt;
	if (!CDBConnectPool::Instance()->DBQuery(stmt, sql))
	{
		ASSERT(FALSE);
		CSimpleLog::Error("执行语句失败" + sql);
		return FALSE;
	}

	int nCol = 1;
	stmt.BindCharCol(nCol++, mo, sizeof(mo));
	stmt.BindCharCol(nCol++, mp, sizeof(mp));
	stmt.BindCharCol(nCol++, imei, sizeof(imei));
	stmt.BindSmallIntCol(nCol++, &idx);
	stmt.BindCharCol(nCol++, name1, sizeof(name1));
	stmt.BindCharCol(nCol++, name2, sizeof(name2));
	stmt.BindCharCol(nCol++, name3, sizeof(name3));
	stmt.BindCharCol(nCol++, direct1, sizeof(direct1));
	stmt.BindCharCol(nCol++, direct2, sizeof(direct2));
	//stmt.BindIntCol(nCol++, &zzj_no);
	//stmt.BindIntCol(nCol++, &epos);
	//stmt.BindTinyIntCol(nCol++, &binstall_1);
	//stmt.BindTinyIntCol(nCol++, &binstall_2);
	//stmt.BindTinyIntCol(nCol++, &binstall_3);

	stringstream smomp;
	stringstream simei;
	while (true)
	{
		memset(imei, 0, sizeof(imei));
		if (stmt.FetchNext() != 0)
		{
			break;
		}

		if (name1[0x00] != 0)
			sprintf_s(name1, 20, "%s%s", name1, "测力曲线");
		if (name2[0x00] != 0)
			sprintf_s(name2, 20, "%s%s", name2, "测力曲线");

		for (int i = 0x00; i < 16; i++)	if (imei[i] == 0x20) imei[i] = 0x00;  //0x20 代表空格

		smomp.str("");
		simei.str("");
		smomp << mo << '.' << mp;
		if (imei[0x00] != 0x00) simei << imei << '.' << idx;

		string momp = smomp.str();
		m_mapMoMpZZJNO[momp] = zzj_no;
		m_mapMoMpZZJEPOS[momp] = (DAOCHA_POSITION)epos;
		m_mapMoMpImeiIdx[momp] = simei.str();
		if (imei[0x00] != 0x00)	m_mapImeiIdxMoMp[simei.str()] = smomp.str();

		{
			auto& it = m_mapMoMpInfo[momp];
			if (it == nullptr) it = new ST_MOMP_INFO;
			//it->binstall_1 = binstall_1;
			//it->binstall_2 = binstall_2;
			//it->binstall_3 = binstall_3;
			it->name1 = name1;
			it->name2 = name2;
			it->name3 = name3;
			it->out_name = direct1;
			it->in_name = direct2;
			it->imei = imei;
			it->idx = idx;
			//it->zzjno = zzj_no;
			it->mo = mo;
			it->mp = mp;
			if (!it->imei.empty())
				it->pDeivce = CDeviceMng::Instance()->Insert(imei);
		}
	}
	
	return m_mapMoMpImeiIdx.size() + 1;
}

void CMonitorObjectMng::GetChild(std::list<CMonitorObject*>& lst, CMonitorObject* parent)
{
	for (auto it = lst.begin(); it != lst.end(); ++it)
	{
		auto p = *it;
		if (p == nullptr) continue;
		if (p->id.compare(p->up) == 0) 
			continue;

		if (p->up.compare(parent->id) == 0)
		{
			if (p->type.compare("mo") == 0)
			{
				for (auto& ik : m_mapMoMpImeiIdx)
				{
					//int ii = ik.first.find('.');
					//int jj = ik.first.find(p->id);
					string strName = p->id + '.';
					if (ik.first.find(strName) != -1)
					{
						auto pObject = new CMonitorObject;
						pObject->id = ik.first;
						pObject->name = p->name + "." + ik.first.substr(ik.first.find('.') + 1);
						pObject->type = "mo.mp";
						pObject->up = parent->id;
						pObject->parent = parent;
						pObject->eqpno = m_mapMoMpZZJNO[pObject->id];
						parent->m_lstMo.push_back(pObject);
					}
				}
			}
			else 
			{
				p->parent = parent;
				parent->m_lstMo.push_back(p);
				*it = nullptr;
				GetChild(lst, p);
			}
		}

		
	}
}

bool CMonitorObjectMng::GetStationNameByMomP(CMonitorObject* pInfo, const std::string& momp, std::string& station, std::string& momp_name)
{
	if (pInfo == nullptr) return false;
	if (pInfo->type.compare("mo.mp") == 0 && pInfo->id.compare(momp) == 0)
	{
		station = pInfo->up;
		momp_name = pInfo->name;
		return true;
	}

	for (const auto& it : pInfo->m_lstMo)
	{
		if (GetStationNameByMomP(it, momp, station, momp_name)) 
			return true;
	}
	return false;
}

void CMonitorObjectMng::Clear()
{
	if (m_treeroot) delete m_treeroot;
	m_treeroot = nullptr;
	m_mapImeiIdxMoMp.clear();
	m_mapMoMpImeiIdx.clear();
	for (auto& it : m_mapMoMpInfo)
		delete it.second;
}

BOOL CMonitorObjectMng::LoadMonitorTree()
{
	Clear();
	if (!LoadMoMap()) return FALSE;

	char id[100];
	char type[50];
	char up[100];
	char name[100];

	CString sql = "SELECT [id],[type],[up],[name] FROM [rm_mo]";

	COdbcStatement stmt;
	if (!CDBConnectPool::Instance()->DBQuery(stmt, sql))
	{
		CSimpleLog::Error("执行语句失败" + sql);
		return FALSE;
	}

	int nCol = 1;
	stmt.BindCharCol(nCol++, id, sizeof(id));
	stmt.BindCharCol(nCol++, type, sizeof(type));
	stmt.BindCharCol(nCol++, up, sizeof(up));
	stmt.BindCharCol(nCol++, name, sizeof(name));

	list<CMonitorObject*> lstMo;
	while (true)
	{
		if (stmt.FetchNext() != 0)
		{
			break;
		}

		auto p = new CMonitorObject;
		p->id = id;
		p->type = type;
		p->up = up;
		p->name = name;

		//赋值节点名称
		if (p->type.compare("mo") == 0)
		{
			for (auto& it : m_mapMoMpInfo)
			{
				if (it.second->mo.compare(id) == 0)
					it.second->name = fmt::format("{}.{}", name, it.second->mp);
			}
		}

		if (p->id.compare(up) == 0)
		{
			swap(m_treeroot, p);
			delete p;
			p = nullptr;
		}
		else
		{
			lstMo.push_back(p);
		}
	}
	

	bool bret = true;
	if (m_treeroot == nullptr)
	{
		assert(0);
		bret = false;
		goto l;

	}

	GetChild(lstMo, m_treeroot);

l:
	for (auto it = lstMo.begin(); it != lstMo.end(); ++it)
		delete (*it);
	lstMo.clear();

	//test 
	//{
	//	string momp = "HZHDJD21.X";
	//	string name, name2;
	//	GetStationNameByMomP(momp, name, name2);
	//}
	return TRUE;
}

BOOL CMonitorObjectMng::LoadHistoryData()
{
	for (auto& it : m_mapMoMpImeiIdx)
	{
		string imei, idx;
		spiltByPoint(it.second, imei, idx);
		if (imei.length() > 5)	CDeviceMng::Instance()->Insert(imei);
	}
	return TRUE;
}

bool CMonitorObjectMng::IMEI2MOMP(const std::string imei, const int idx, std::string& mo, std::string& mp)
{
	auto& it = m_mapImeiIdxMoMp.find(concatStringByPoint(imei, to_string(idx)));
	if (it == m_mapImeiIdxMoMp.end()) return false;
	return spiltByPoint(it->second, mo, mp);
}

bool CMonitorObjectMng::IMEI2MOMP(const std::string& imei_idx, std::string& mo_mp)
{
	auto& it = m_mapImeiIdxMoMp.find(imei_idx);
	if (it == m_mapImeiIdxMoMp.end()) return false;
	mo_mp = it->second;
	return true;
}

bool CMonitorObjectMng::MOMP2IMEI(const std::string& mo, const std::string& mp, std::string& imei, int& idx)
{
	auto& it = m_mapMoMpImeiIdx.find(concatStringByPoint(mo, mp));
	if (it == m_mapMoMpImeiIdx.end()) return false;
	string idx2;
	if (!spiltByPoint(it->second, imei, idx2)) return false;
	idx = atoi(idx2.c_str());
	return true;
}

bool CMonitorObjectMng::MOMP2IMEI(const std::string& momp, std::string& imeiidx)
{
	auto& it = m_mapMoMpImeiIdx.find(momp);
	if (it == m_mapMoMpImeiIdx.end()) return false;
	if (it->second.length() <= 0) return false;
	imeiidx = it->second;
	return true;
}

bool CMonitorObjectMng::MOMP2IMEI(const std::string& momp, std::string& imei, int& idx)
{
	auto& it = m_mapMoMpImeiIdx.find(momp);
	if (it == m_mapMoMpImeiIdx.end()) return false;
	string idx2;
	if (!spiltByPoint(it->second, imei, idx2)) return false;
	idx = atoi(idx2.c_str());
	return true;
}

bool CMonitorObjectMng::GetStationNameByMomP(const std::string& momp, std::string& station, std::string& momp_name)
{
	return GetStationNameByMomP(m_treeroot, momp, station, momp_name);
}

bool CMonitorObjectMng::GetStationNameByMomP(const std::string& mo, const std::string& mp, std::string& station, std::string& momp_name)
{
	return GetStationNameByMomP(m_treeroot, mo + "." + mp, station, momp_name);
}

bool CMonitorObjectMng::spiltByPoint(const std::string&src, std::string& dst1, std::string& dst2)
{
	auto pos = src.find('.');
	if (pos == -1) return false;
	dst1 = src.substr(0, pos);
	dst2 = src.substr(pos + 1);
	return true;
}

std::string CMonitorObjectMng::concatStringByPoint(const std::string& src1, const std::string& src2)
{
	stringstream ss;
	ss << src1 << "." << src2;
	return ss.str();
}

CMonitorObject* CMonitorObjectMng::GetTreeByID(CMonitorObject* p, const string& id)
{
	if (p->id.compare(id) == 0)
	{
		return p;
	}
	else
	{
		for (const auto& it : p->m_lstMo)
		{
			auto pObj = GetTreeByID(it, id);
			if (pObj) return pObj;
		}
	}
	return nullptr;
}

CMonitorObject* CMonitorObjectMng::GetTreeByEpqID(CMonitorObject* p, uint16_t id)
{
	if (p->eqpno == id)
	{
		return p;
	}
	else
	{
		for (const auto& it : p->m_lstMo)
		{
			auto pObj = GetTreeByEpqID(it, id);
			if (pObj) return pObj;
		}
	}
	return nullptr;
}


CMonitorObject* CMonitorObjectMng::GetTreeByID(const string& id)
{
	CMonitorObject* pObject = nullptr;
	do {
		if (m_treeroot == nullptr) break;
		return GetTreeByID(m_treeroot, id);
	} while (false);
	return pObject;
}

CMonitorObject* CMonitorObjectMng::GetTreeByEpqID(uint16_t id)
{
	CMonitorObject* pObject = nullptr;
	do {
		if (m_treeroot == nullptr) break;
		return GetTreeByEpqID(m_treeroot, id);
	} while (false);
	return pObject;
}

void CMonitorObjectMng::GetAllObjByType(CMonitorObject* p, std::vector<CMonitorObject*>& vctObj, const string& type)
{
	if (p->type.compare(type) == 0)
	{
		vctObj.push_back(p);
	}
	for (auto& it : p->m_lstMo)
	{
		GetAllObjByType(it, vctObj, type);
	}
}


//获取所有Type对象
bool CMonitorObjectMng::GetAllObjByType(std::vector<CMonitorObject*>& vctObj, const string& type)
{
	do {
		if (m_treeroot == nullptr) break;
		GetAllObjByType(m_treeroot, vctObj, type);
	} while (false);

	return !vctObj.empty();
}

void CMonitorObjectMng::GeneralMoPack(CMonitorObject* pObject, yyjson_mut_doc* doc, yyjson_mut_val* val)
{
	yyjson_mut_obj_add_str(doc, val, "id", pObject->id.c_str());
	yyjson_mut_obj_add_str(doc, val, "name", pObject->name.c_str());
	yyjson_mut_obj_add_str(doc, val, "type", pObject->type.c_str());
	yyjson_mut_obj_add_str(doc, val, "up", pObject->up.c_str());
	yyjson_mut_val* arr = nullptr;
	if (pObject->m_lstMo.size() > 0)
	{
		arr = yyjson_mut_arr(doc);
		yyjson_mut_obj_add_val(doc, val, "child", arr);
	}
	for (auto& it : pObject->m_lstMo)
	{
		auto object = yyjson_mut_obj(doc);
		yyjson_mut_arr_add_val(arr, object);
		GeneralMoPack(it, doc, object);
	}
}

void CMonitorObjectMng::UpdateZZJEPOS(const string& momp, DAOCHA_POSITION epos)
{
	string mo, mp;
	spiltByPoint(momp, mo, mp);
	CString sql = fmt::format("UPDATE rm_map SET epos = {} where mo = '{}' and mp = '{}'", int(epos), mo, mp).c_str();
	auto ret = CDBConnectPool::Instance()->DBExecuteSQL(sql);
	if (ret)
	{
		m_mapMoMpZZJEPOS[momp] = epos;
	}
	else
	{
		CSimpleLog::Error("更新语句错误:" + sql);
	}
}

CMonitorObjectMng CMonitorObjectMng::obj;