OTS/OTSCPP/OTSRptCalculate/DTL/XRayDataDB.cpp

#pragma once
#include "stdafx.h"
#include "XRayDataDB.h"
#include "XRayDataTable.h"

namespace OTSSQLITE
{
	
	CXRayDataDB::CXRayDataDB(CDBStoreBasePtr a_datastore)	
	{
		m_tableInfo.reset(new CXRayDataTable());
		myDB = CreateNewSQLiteDB(a_datastore,m_tableInfo);
	}

	CXRayDataDB::~CXRayDataDB()
	{
	}

	CPosXrayPtr CXRayDataDB::GetXRayDataById(const long a_nXrayId, const long a_nFieldId)
	{
		CPosXrayPtr pPosXray;

		if (!m_listPosXray.empty())
		{
			for (auto pxray : m_listPosXray)
			{
				if (pxray->GetIndex() == (DWORD)a_nXrayId && pxray->GetScanFieldId() == a_nFieldId)
				{
					pPosXray = pxray;
				}
			}
		}
		else
		{
			auto tableQuery = GetQueryById(a_nXrayId, a_nFieldId);
			ASSERT(tableQuery);
			if (!tableQuery)
			{
				return pPosXray;
			}
			CPosXrayPtr pPosXray;
			pPosXray = CPosXrayPtr(new CPosXray());
			if (!ReadOnePosXray(tableQuery,pPosXray))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("read x-ray failed."));
				return pPosXray;
			}

			return pPosXray ;

		}

		return pPosXray;
	}
	CPosXrayList& CXRayDataDB::GetXrayList(const BOOL a_bForce/* = FALSE*/)
	{
		if (a_bForce)
		{
			m_listPosXray.clear();
		}

		if (m_listPosXray.size() == 0)
		{
			ReadAllXrayList();
		}

		return m_listPosXray;
	}
	BOOL CXRayDataDB::SavePosXrayPtr(const CPosXrayPtr a_pXray)
	{
		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;
		DWORD* xrayData = a_pXray->GetXrayData();
			sSQLCommand.Format(sInsertFormat,
				a_pXray->GetIndex(),
				a_pXray->GetScanFieldId()
				);

			char * sql = sSQLCommand.GetBuffer();
			if (!datastorePtr->InsertBlobData (sql,xrayData, GENERALXRAYCHANNELS*4))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("Insert x-ray data(%d:%d:%d) failed: %s command error"),
					a_pXray->GetIndex(),
					a_pXray->GetScanFieldId(),					
					0,
					sSQLCommand);

				ASSERT(FALSE);
				return FALSE;
			}
		return TRUE;
	}
	BOOL CXRayDataDB::DeletePosXrayById(const long a_nFieldId, const long a_nXrayId)
	{
		if (!m_listPosXray.empty())
		{
			std::remove_if(m_listPosXray.begin(), m_listPosXray.end(), [a_nFieldId, a_nXrayId](const CPosXrayPtr& xrayPoint) { return(xrayPoint->GetIndex() == (DWORD)a_nXrayId) && (xrayPoint->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)CXRayDataTable::ColumnID::N_INDEX - (int)CXRayDataTable::ColumnID::MIN);
		CString sFieldIdColumnName = tableInfoPtr->GetColumnName((int)CXRayDataTable::ColumnID::N_FIELD_ID - (int)CXRayDataTable::ColumnID::MIN);

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

		return datastorePtr->RunCommand(sSQLCommand);
	}
	CDBTableBasePtr CXRayDataDB::GetTableInfo()
	{

		return m_tableInfo;
	}

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

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

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

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

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

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

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

	BOOL CXRayDataDB::ReadAllXrayList()
	{

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

		ReadXrayListFromAQuery(query,m_listPosXray);

		return TRUE;
	}
	BOOL CXRayDataDB::ReadXrayListFromAQuery(CDBQueryBasePtr a_query, CPosXrayList& a_XrayList)
	{
		int nWrongItems = 0;
		while (!a_query->IsEOF())
		{
			CPosXrayPtr pPosXray;
			pPosXray = CPosXrayPtr(new CPosXray());
			if (!ReadOnePosXray(a_query, pPosXray))	//current x-ray point		
			{
				LogErrorTrace(__FILE__, __LINE__, _T("Read xray point failed"));
				nWrongItems++;
				break;
			}			

			a_XrayList.push_back(pPosXray);
			
			a_query->NextRow();
		
		}

		return true;
	}
	BOOL CXRayDataDB::ReadOnePosXray(CDBQueryBasePtr a_query, CPosXrayPtr& a_xray)
	{
		int nCol;
		

		int nXrayIdNow;
		int nFieldIdNow;

		nCol = (int)CXRayDataTable::ColumnID::N_INDEX - (int)CXRayDataTable::ColumnID::MIN;
		nXrayIdNow = a_query->GetColIntValue(nCol, -1);
		a_xray->SetIndex(nXrayIdNow);

		nCol = (int)CXRayDataTable::ColumnID::N_FIELD_ID - (int)CXRayDataTable::ColumnID::MIN;
		nFieldIdNow = a_query->GetColIntValue(nCol, -1);
		a_xray->SetScanFieldId(nFieldIdNow);

		nCol = (int)CXRayDataTable::ColumnID::N_XRAY_DATA - (int)CXRayDataTable::ColumnID::MIN;
		int i = 2;
		const unsigned char* XrayData = a_query->GetColBlobValue(nCol, i);
		for (int j = 0; j < GENERALXRAYCHANNELS; j++)
		{
			int m = j * 4;
			DWORD d = XrayData[m + 3];
			d=d << 8;
			d = d | XrayData[m + 2];
			d=d << 8;
			d = d | XrayData[m + 1];
			d=d << 8;
			d = d | XrayData[m];
			a_xray->SetXrayDataAtChannel(d, j);

		}
		

		
		
		return TRUE;
	}
	CDBQueryBasePtr CXRayDataDB::GetQueryById(const long a_nXrayId, const long a_nFieldId)
	{
		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)CXRayDataTable::ColumnID::N_INDEX - (int)CXRayDataTable::ColumnID::MIN);
		CString sFieldIdColumnName = tableInfoPtr->GetColumnName((int)CXRayDataTable::ColumnID::N_FIELD_ID - (int)CXRayDataTable::ColumnID::MIN);

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

		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;
	}
}