OTS/OTSCPP/OTSRptCalculate/DTL/ElementChemistryDB.cpp

#pragma once
#include "stdafx.h"
#include "ElementChemistryDB.h"
#include "ElementChemistryTable.h"

namespace OTSSQLITE
{
	CElementChemistryDB::CElementChemistryDB(CDBStoreBasePtr a_datastore)		
	{
		m_tableInfo.reset(new CElementChemistryTable());
		myDB = CreateNewSQLiteDB(a_datastore,m_tableInfo);
		
	}
	
	CElementChemistryDB::~CElementChemistryDB()
	{
	}

	CElementChemistriesList CElementChemistryDB::GetElementChemistryListById(const long a_nXrayId, const long a_nFieldId, const long a_nElementSize)
	{
		CElementChemistriesList listElementChemistry;

		if (!m_listPosXrayInfo.empty())
		{
			for (auto& xrayPointInfo : m_listPosXrayInfo)
			{
				if (xrayPointInfo->GetIndex() == (DWORD)a_nXrayId && xrayPointInfo->GetScanFieldId() == a_nFieldId && xrayPointInfo->GetElementNum() == a_nElementSize)
				{
					listElementChemistry = xrayPointInfo->GetElementQuantifyData();
				}
			}
		}
		else
		{
			// read element list
			for (int i = 0; i < a_nElementSize; i++)
			{
				auto tableQuery = GetQueryById(a_nXrayId, a_nFieldId, i, a_nElementSize);
				ASSERT(tableQuery);
				if (!tableQuery)
				{
					return listElementChemistry;
				}

				auto pXrayInfoMap = ReadPosXrayInfo(tableQuery);
				if (pXrayInfoMap.size()==0)
				{
					return listElementChemistry;
				}
				std::vector<int> idvec;
				idvec.push_back(a_nFieldId);
				idvec.push_back(a_nXrayId);

				 listElementChemistry = pXrayInfoMap[idvec]->GetElementQuantifyData();
				
			}	

		}

		return listElementChemistry;
	}	
	
	




	//}
	BOOL CElementChemistryDB::SaveElementChemistriesList(const CPosXrayList& a_xrayPointList)
	{
		if (!Init())
		{
			ASSERT(FALSE);
			return FALSE;
		}

		auto tableInfoPtr = GetTableInfo();
		ASSERT(tableInfoPtr);
		if (!tableInfoPtr)
		{
			return FALSE;
		}

		auto datastorePtr = GetDatastore();
		ASSERT(datastorePtr);
		if (!datastorePtr)
		{
			return FALSE;
		}

		CString sInsertFormat = tableInfoPtr->GetInsertCommandFormatString(TRUE);
		CString sSQLCommand;

		for (auto& xrayPointInfo : a_xrayPointList)
		{
			CElementChemistriesList listElemnentChemistries = xrayPointInfo->GetElementQuantifyData();

			int nSize = (int)listElemnentChemistries.size();
			int nElementIndex = 0;
			for (auto& pElementChemistry : listElemnentChemistries)
			{
				sSQLCommand.Format(sInsertFormat,
					xrayPointInfo->GetIndex(),
					xrayPointInfo->GetScanFieldId(),
					nElementIndex,
					nSize,
					pElementChemistry->GetName(),
					pElementChemistry->GetPercentage());

				if (!datastorePtr->RunCommand(sSQLCommand))
				{
					LogErrorTrace(__FILE__, __LINE__, _T("Insert element(%d:%d:%d:%d) failed: %s command error"),
						xrayPointInfo->GetIndex(),
						xrayPointInfo->GetScanFieldId(),
						nElementIndex,
						nSize,
						pElementChemistry->GetName(),
						pElementChemistry->GetPercentage(),
						sSQLCommand);

					ASSERT(FALSE);
					return FALSE;
				}

				nElementIndex++;
			}

		}

		return TRUE;
	}

	BOOL CElementChemistryDB::SaveElementChemistriesList(const CPosXrayPtr a_pxrayPoint)
	{
		if (!Init())
		{
			ASSERT(FALSE);
			return FALSE;
		}

		auto tableInfoPtr = GetTableInfo();
		ASSERT(tableInfoPtr);
		if (!tableInfoPtr)
		{
			return FALSE;
		}

		auto datastorePtr = GetDatastore();
		ASSERT(datastorePtr);
		if (!datastorePtr)
		{
			return FALSE;
		}

		CString sInsertFormat = tableInfoPtr->GetInsertCommandFormatString(TRUE);
		CString sSQLCommand;

		CElementChemistriesList listElemnentChemistries = a_pxrayPoint->GetElementQuantifyData();

		int nSize = (int)listElemnentChemistries.size();
		int nElementIndex = 0;
		for (auto& pElementChemistry : listElemnentChemistries)
		{
			sSQLCommand.Format(sInsertFormat,
				a_pxrayPoint->GetIndex(),
				a_pxrayPoint->GetScanFieldId(),
				nElementIndex,
				nSize,
				pElementChemistry->GetName(),
				pElementChemistry->GetPercentage(),
				pElementChemistry->GetMolarPercentage());

			if (!datastorePtr->RunCommand(sSQLCommand))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("Insert element(%d:%d:%d:%d) failed: %s command error"),
					a_pxrayPoint->GetIndex(),
					a_pxrayPoint->GetScanFieldId(),
					nElementIndex,
					nSize,
					pElementChemistry->GetName(),
					pElementChemistry->GetPercentage(),
					pElementChemistry->GetMolarPercentage(),
					sSQLCommand);

				ASSERT(FALSE);
				return FALSE;
			}

			nElementIndex++;
		}
		
		return TRUE;
	}

	BOOL CElementChemistryDB::DeleteElementChemistryById(const long a_nFieldId, const long a_nXrayId)
	{
		if (!m_listPosXrayInfo.empty())
		{
			std::remove_if(m_listPosXrayInfo.begin(), m_listPosXrayInfo.end(), [a_nFieldId, a_nXrayId](const CPosXrayPtr& xrayPointInfo) { return( xrayPointInfo->GetIndex() == (DWORD)a_nXrayId)&&(xrayPointInfo->GetScanFieldId() == (DWORD)a_nFieldId); });
		}

		auto tableInfoPtr = GetTableInfo();
		ASSERT(tableInfoPtr);
		if (!tableInfoPtr)
		{
			return FALSE;
		}

		auto datastorePtr = GetDatastore();
		ASSERT(datastorePtr);
		if (!datastorePtr)
		{
			return FALSE;
		}

		CString sTableName = tableInfoPtr->GetTableName();
		if (!datastorePtr->IsTableExists(sTableName))
		{
			LogTrace(__FILE__, __LINE__, _T("Table %s not exist"), sTableName);
			return TRUE;
		}

		CString sXrayIdColumnName = tableInfoPtr->GetColumnName((int)CElementChemistryTable::ColumnID::N_XRAY_INDEX - (int)CElementChemistryTable::ColumnID::MIN);
		CString sFieldIdColumnName = tableInfoPtr->GetColumnName((int)CElementChemistryTable::ColumnID::N_FIELD_ID - (int)CElementChemistryTable::ColumnID::MIN);
		
		CString sSQLCommand;
		sSQLCommand.Format(_T("DELETE FROM \'%s\' WHERE %s = %d AND %s = %d AND %s = %d AND %s = %d;"),
			(LPCTSTR)tableInfoPtr->GetTableName(),
			(LPCTSTR)sXrayIdColumnName,
			a_nXrayId,
			(LPCTSTR)sFieldIdColumnName,
			a_nFieldId);

		return datastorePtr->RunCommand(sSQLCommand);
	}

	CDBTableBasePtr CElementChemistryDB::GetTableInfo()
	{
		

		return m_tableInfo;
	}
	
	BOOL CElementChemistryDB::Init(const BOOL a_bClean /*= FALSE*/)
	{
		return myDB->Init();
	}

	BOOL CElementChemistryDB::CreateTable(const BOOL a_bForce /*= FALSE*/)
	{
		return myDB->CreateTable(a_bForce);
	}

	BOOL CElementChemistryDB::DeleteTable()
	{
		return myDB->DeleteTable();
	}

	BOOL CElementChemistryDB::RemoveAllRows()
	{
		return myDB->RemoveAllRows();
	}

	BOOL CElementChemistryDB::IsDBExist()
	{
		return myDB->IsDBExist();
	}

	OTSSQLITE::CDBStoreBasePtr CElementChemistryDB::GetDatastore()
	{
		return myDB->GetDatastore();
	}

	OTSSQLITE::CDBQueryBasePtr CElementChemistryDB::GetTableQuery(LPCTSTR a_sOrderColumnName /*= nullptr*/)
	{
		return myDB->GetTableQuery(a_sOrderColumnName);
	}

	

	
	std::map<std::vector<int>, CPosXrayPtr> CElementChemistryDB::ReadPosXrayInfo(OTSSQLITE::CDBQueryBasePtr a_query)
	{

		std::map<std::vector<int>, CPosXrayPtr> mapXrayInfo;
		CDBQueryBasePtr query;
		if (a_query == nullptr)
		{
			auto tableInfoPtr = GetTableInfo();
			ASSERT(tableInfoPtr);
			if (!tableInfoPtr)
			{
				return mapXrayInfo;
			}

			 query = GetTableQuery();
			ASSERT(query);
			if (!query)
			{
				return mapXrayInfo;
			}

		}
		else
		{
			query = a_query;
		}
		

		while (!query->IsEOF())
		{

			CPosXrayPtr xrayInfo;
			int nCol;
			

			int nXrayIdNow;
			int nFieldIdNow;

			nCol = (int)CElementChemistryTable::ColumnID::N_XRAY_INDEX - (int)CElementChemistryTable::ColumnID::MIN;
			nXrayIdNow = query->GetColIntValue(nCol, -1);
		

			nCol = (int)CElementChemistryTable::ColumnID::N_FIELD_ID - (int)CElementChemistryTable::ColumnID::MIN;
			nFieldIdNow = query->GetColIntValue(nCol, -1);
			

			std::vector <int> fldvec;
			fldvec.push_back(nFieldIdNow);
			fldvec.push_back(nXrayIdNow);

			if (mapXrayInfo.find(fldvec) != mapXrayInfo.end())
			{
				 xrayInfo = mapXrayInfo[fldvec];


			}
			else
			{
				CPosXrayPtr xrayPointPtr(new CPosXray());
				mapXrayInfo[fldvec] = xrayPointPtr;
				xrayPointPtr->SetIndex(nXrayIdNow);
				xrayPointPtr->SetScanFieldId(nFieldIdNow);
				xrayInfo = xrayPointPtr;
			}


			nCol = (int)CElementChemistryTable::ColumnID::N_ELEMENT_ID - (int)CElementChemistryTable::ColumnID::MIN;
			int nElementIndex = query->GetColIntValue(nCol, -1);

			nCol = (int)CElementChemistryTable::ColumnID::N_ELEMENT_TOTAL - (int)CElementChemistryTable::ColumnID::MIN;
			int nElementTotal = query->GetColIntValue(nCol, -1);
			xrayInfo->SetElementNum(nElementTotal);



			CElementChemistryPtr pElementChemistry = CElementChemistryPtr(new CElementChemistry());

			nCol = (int)CElementChemistryTable::ColumnID::S_NAME - (int)CElementChemistryTable::ColumnID::MIN;
			pElementChemistry->SetName(query->GetColStringValue(nCol, _T("")));

			nCol = (int)CElementChemistryTable::ColumnID::F_PERCENTAGE - (int)CElementChemistryTable::ColumnID::MIN;
			pElementChemistry->SetPercentage(query->GetColFloatValue(nCol, -1));

		

			xrayInfo->AddElementQuantifyData(pElementChemistry);

			query->NextRow();

		}
		return mapXrayInfo;
		
	}
	
	CDBQueryBasePtr CElementChemistryDB::GetQueryById(const long a_nXrayId,const long a_nFieldId, const long a_nElementId, const long a_nElementSize)
	{
		CDBQueryBasePtr query;
		auto datastorePtr = GetDatastore();
		ASSERT(datastorePtr);
		if (!datastorePtr)
		{
			return query;
		}

		auto tableInfoPtr = GetTableInfo();
		ASSERT(tableInfoPtr);
		if (!tableInfoPtr)
		{
			return query;
		}

		CString sXrayIdColumnName = tableInfoPtr->GetColumnName((int)CElementChemistryTable::ColumnID::N_XRAY_INDEX - (int)CElementChemistryTable::ColumnID::MIN);
		CString sFieldIdColumnName = tableInfoPtr->GetColumnName((int)CElementChemistryTable::ColumnID::N_FIELD_ID - (int)CElementChemistryTable::ColumnID::MIN);
		CString sElementIdColumnName = tableInfoPtr->GetColumnName((int)CElementChemistryTable::ColumnID::N_ELEMENT_ID - (int)CElementChemistryTable::ColumnID::MIN);
		CString sElementNumColumnName = tableInfoPtr->GetColumnName((int)CElementChemistryTable::ColumnID::N_ELEMENT_TOTAL - (int)CElementChemistryTable::ColumnID::MIN);

		CString sSQLCommand;
		sSQLCommand.Format(_T("SELECT * FROM \'%s\' WHERE %s = %d AND %s = %d AND %s = %d AND %s = %d;"),
			(LPCTSTR)tableInfoPtr->GetTableName(),
			(LPCTSTR)sFieldIdColumnName,
			a_nFieldId,
			(LPCTSTR)sXrayIdColumnName,
			a_nXrayId,
			(LPCTSTR)sElementIdColumnName,
			a_nElementId,
			(LPCTSTR)sElementNumColumnName,
			a_nElementSize);

		query = datastorePtr->QueryByCommand(sSQLCommand);
		ASSERT(query);
		if (!query || !query->IsValid())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Invalid quary command (%s)."), (LPCTSTR)sSQLCommand);
			ASSERT(FALSE);
			return (CDBQueryBasePtr());
		}

		// do the table related valid checking
		if (query->GetColCount() != GetTableInfo()->GetColumnCount())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("query col num value is %d, but not %d"), query->GetColCount(), GetTableInfo()->GetColumnCount());
			ASSERT(FALSE);
			return (CDBQueryBasePtr());
		}

		return query;
	}
	
	

}