OTS/OTSCPP/OTSClassifyEngine/SpectrumCompareEngine/OTSSTDLibFileMgr.cpp

#include "stdafx.h"
#include "OTSSTDLibFileMgr.h"
#include "OTSFileSys.h"
using namespace OTSTools;
namespace OTSClassifyEngine
{
	// project file extension
	const CString ORETYPE_FILE_EXT = _T("db");
	const CString ORETYPE_FILE_FILTER = _T("Particle Type Files (*.db)|*.db|All Files (*.*)|*.*||");
	const CString SysSTDLibFilePath = ".\\Config\\SysData\\";
	// constructor
	CSTDLibFileMgr::CSTDLibFileMgr(std::string fileName)
	{
		m_strPathName = SysSTDLibFilePath+fileName.c_str();

		Init();
	}

	// destructor
	CSTDLibFileMgr::~CSTDLibFileMgr()
	{
		// cleanup
		Cleanup();
	}

	BOOL CSTDLibFileMgr::CreateSTDLibFile()
	{
		// check file name
		m_strPathName.Trim();
		if (m_strPathName.IsEmpty())
		{
			// error, wrong file name
			LogErrorTrace(__FILE__, __LINE__, _T("Empty file path name"));
			ASSERT(FALSE);
			return FALSE;
		}
		if (COTSFileSys::Exists(m_strPathName))
		{
			if (!Open(m_strPathName, FALSE))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("Open STD file failed."));
				ASSERT(FALSE);
				return FALSE;
			}
		}
		else
		{
			if (!Create(m_strPathName))
			{
				LogErrorTrace(__FILE__, __LINE__, _T("Create X-ray file failed."));
				ASSERT(FALSE);
				return FALSE;
			}
		}
		return TRUE;
	}



	// Load/Save
	BOOL CSTDLibFileMgr::LoadSTDSpectrumItems(CSTDSpectrumItemList& itms, BOOL bClear /*= TRUE*/)
	{
		
;
		// program manager param file exists?
		if (!COTSFileSys::Exists(m_strPathName))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GenerateSTDLib: there is no STD lib file."+ m_strPathName));
			return FALSE;
		}
		
		
		
		if (!CreateSTDLibFile())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Create or open STD file failed."));
			return FALSE;
		}

		m_pSTDLibDB=GetSTDLibDB();
	
		auto specItms=	m_pSTDLibDB->GetSTDItems(bClear);
		for (auto itm : specItms)
		{
			itms.push_back(itm);
		}

		return TRUE;
	}

	BOOL CSTDLibFileMgr::LoadPartSTD(ParticleSTDPtr lib, BOOL bClear /*= TRUE*/)
	{
		//AFX_MANAGE_STATE(AfxGetStaticModuleState());

		if (!COTSFileSys::Exists(m_strPathName))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GenerateSTDLib: there is no STD lib file."+ m_strPathName));
			return FALSE;
		}
		if (!CreateSTDLibFile())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Create or open STD file failed."));
			return FALSE;
		}

		GetParticleSTDDB();

		 m_pParticleSTDDB->GetPartSTDLib(lib,bClear);

		return TRUE;
	}

	BOOL CSTDLibFileMgr::LoadZeroElementRulesData(ParticleSTDPtr lib, BOOL bClear /*= TRUE*/)
	{
		//AFX_MANAGE_STATE(AfxGetStaticModuleState());

		if (!COTSFileSys::Exists(m_strPathName))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GenerateSTDLib: there is no STD lib file."));
			return FALSE;
		}
		if (!CreateSTDLibFile())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Create or open STD file failed."));
			return FALSE;
		}

		GetZeroElementRulesDataDB();

		auto rules= m_pZeroElementRulesDataDB->GetZeroElementRulesLib(bClear);
		lib->setZeroElementRuleList(rules);

		return TRUE;
	}

	BOOL CSTDLibFileMgr::LoadMaxEDSRulesData(ParticleSTDPtr lib, BOOL bClear /*= TRUE*/)
	{

		if (!COTSFileSys::Exists(m_strPathName))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GenerateSTDLib: there is no STD lib file."));
			return FALSE;
		}
		if (!CreateSTDLibFile())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Create or open STD file failed."));
			return FALSE;
		}

		m_pMaxEDSRulesDataDB=GetMaxEDSRulesDataDB();

	auto 	maxedsrls = m_pMaxEDSRulesDataDB->GetMaxEDSRulesLib(bClear);
	lib->setMaxEDSRuleList(maxedsrls);

		return TRUE;
	}

	std::string CSTDLibFileMgr::LoadConstantsData( BOOL bClear /*= TRUE*/)
	{
		//AFX_MANAGE_STATE(AfxGetStaticModuleState());

		if (!COTSFileSys::Exists(m_strPathName))
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GenerateSTDLib: there is no STD lib file."));
			return FALSE;
		}
		if (!CreateSTDLibFile())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Create or open STD file failed."));
			return FALSE;
		}

		GetConstantsDataDb();

		return  m_pConstantsDataDb->GetConstantsLib(bClear);

		//return TRUE;
	}

	BOOL CSTDLibFileMgr::InsertSpectrumSTDItemIntoDB(CSTDSpectrumItemPtr itm)
	{
		if (!CreateSTDLibFile())
		{
			LogErrorTrace(__FILE__, __LINE__, _T("Create or open STD file failed."));
			return FALSE;
		}


		auto specDB = GetSTDLibDB();
		auto specTableInfoPtr = specDB->GetTableInfo();
		auto datastorePtr = specDB->GetDatastore();
		auto sInsertFormat = specTableInfoPtr->GetInsertCommandFormatString(TRUE);

		CString sSQLCommand;

		DWORD* xrayData =itm->GetXraySpectrum()->GetXrayData();
		sSQLCommand.Format(sInsertFormat,
			itm->GetID(),
			itm->GetName(),
			"",
			0.0,
			0,
			0,
			0,
			itm->GetColor()

			
			
		);
		
		auto sql = sSQLCommand.GetBuffer();
		if (!datastorePtr->InsertBlobData(sql, xrayData, GENERALXRAYCHANNELS * 4))
		{


			ASSERT(FALSE);
			return FALSE;
		}

		return TRUE;
	}

	CSTDLibDBPtr CSTDLibFileMgr::GetSTDLibDB()
	{
		if (!m_pSTDLibDB)
		{
			auto datastorePtr = GetDatastore();
			if (datastorePtr)
			{
				m_pSTDLibDB = std::make_shared<CSTDLibDB>(datastorePtr);
			}
		}

		ASSERT(m_pSTDLibDB);

		return m_pSTDLibDB;
	}

	CParticleSTDDBPtr CSTDLibFileMgr::GetParticleSTDDB()
	{
		if (!m_pParticleSTDDB)
		{
			auto datastorePtr = GetDatastore();
			if (datastorePtr)
			{
				m_pParticleSTDDB = std::make_shared<CParticleSTDDB>(datastorePtr);
			}
		}

		ASSERT(m_pParticleSTDDB);

		return m_pParticleSTDDB;
	}

	OTSClassifyEngine::CConstantsDataDbPtr CSTDLibFileMgr::GetConstantsDataDb()
	{
		if (!m_pConstantsDataDb)
		{
			auto datastorePtr = GetDatastore();
			if (datastorePtr)
			{
				m_pConstantsDataDb = std::make_shared<CConstantsDataDb>(datastorePtr);
			}
		}

		ASSERT(m_pConstantsDataDb);

		return m_pConstantsDataDb;
	}

	OTSClassifyEngine::CMaxEDSRulesDataDBPtr CSTDLibFileMgr::GetMaxEDSRulesDataDB()
	{
		if (!m_pMaxEDSRulesDataDB)
		{
			auto datastorePtr = GetDatastore();
			if (datastorePtr)
			{
				m_pMaxEDSRulesDataDB = std::make_shared<CMaxEDSRulesDataDB>(datastorePtr);
			}
		}

		ASSERT(m_pMaxEDSRulesDataDB);

		return m_pMaxEDSRulesDataDB;
	}

	OTSClassifyEngine::CZeroElementRulesDataDBPtr CSTDLibFileMgr::GetZeroElementRulesDataDB()
	{
		if (!m_pZeroElementRulesDataDB)
		{
			auto datastorePtr = GetDatastore();
			if (datastorePtr)
			{
				m_pZeroElementRulesDataDB = std::make_shared<CZeroElementRulesDataDB>(datastorePtr);
			}
		}

		ASSERT(m_pZeroElementRulesDataDB);

		return m_pZeroElementRulesDataDB;
	}

	void CSTDLibFileMgr::Init()
	{
	}

	void CSTDLibFileMgr::Cleanup()
	{
	}
}