OTS/OTSCPP/OTSClassifyEngine/ExpressionParseEngine/ZeroElementRulesDataDB.cpp

#include "stdafx.h"
#include "ZeroElementRulesDataDB.h"
#include "ZeroElementRulesDataTable.h"

namespace OTSClassifyEngine
{
	using namespace OTSSQLITE;
	CZeroElementRulesDataDB::CZeroElementRulesDataDB(CDBStoreBasePtr a_datastore)
	{
		m_tableInfo.reset(new CZeroElementRulesDataTable());
		myDB = CreateNewSQLiteDB(a_datastore, m_tableInfo);
	}

	CZeroElementRulesDataDB::~CZeroElementRulesDataDB()
	{
	}



	CDBTableBasePtr CZeroElementRulesDataDB::GetTableInfo()
	{
		/*if (!m_tableInfo)
		{
			m_tableInfo.reset(new CSTDDataTable);
		}*/

		return m_tableInfo;
	}

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

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

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

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

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

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

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

	
	ZeroElementRuleList CZeroElementRulesDataDB::GetZeroElementRulesLib(BOOL bForce /*= FALSE*/)
	{

		auto query = GetTableQuery("ZeroElement");
		ASSERT(query);
		
		auto ZeroElementRulelist = ReadZeroElementRuleList(query);

		return ZeroElementRulelist;
	}

	ZeroElementRuleList CZeroElementRulesDataDB::ReadZeroElementRuleList(CDBQueryBasePtr a_query)
	{
		ZeroElementRuleList listSTDItem;

		int nRowId = 0;
		int nWrongItems = 0;
		while (!a_query->IsEOF())
		{
			if (!ReadZeroElementRuleItem(a_query))	//current x-ray point		
			{
				LogErrorTrace(__FILE__, __LINE__, _T("Read xray point failed"));
				nWrongItems++;
				break;
			}

			listSTDItem.push_back(m_ZeroElementRuleItem);

			a_query->NextRow();
			nRowId++;
		}

		return listSTDItem;
	}

	BOOL CZeroElementRulesDataDB::ReadZeroElementRuleItem(CDBQueryBasePtr a_query)
	{
		int nCol;
		m_ZeroElementRuleItem = ZeroElementRulePtr(new ZeroElementRule());

		CString sZeroElement;
		nCol = (int)CZeroElementRulesDataTable::ColumnID::S_ZeroElement - (int)CZeroElementRulesDataTable::ColumnID::MIN;
		sZeroElement = a_query->GetColStringValue(nCol, _T(""));
		m_ZeroElementRuleItem->SetZeroElementName(sZeroElement.GetString());


		CString sUsingElementList;
		nCol = (int)CZeroElementRulesDataTable::ColumnID::S_UsingElementList - (int)CZeroElementRulesDataTable::ColumnID::MIN;
		sUsingElementList = a_query->GetColStringValue(nCol, _T(""));
		CElementsList elelist;
		std::vector < std::string> UsingElementStrlist;
		xmls::SplitString(sUsingElementList.GetBuffer(), UsingElementStrlist, ",");
		for (auto s : UsingElementStrlist)
		{
			CElementPtr ele = CElementPtr(new CElement(s.c_str()));
			elelist.push_back(ele);
		}
		m_ZeroElementRuleItem->SetUsingElementList(elelist);

		CString sUsingImgPropertyList;
		nCol = (int)CZeroElementRulesDataTable::ColumnID::S_UsingImgPropertyList - (int)CZeroElementRulesDataTable::ColumnID::MIN;
		sUsingImgPropertyList = a_query->GetColStringValue(nCol, _T(""));
		std::vector < std::string> UsingImgPropertyStrlist;
		xmls::SplitString(sUsingImgPropertyList.GetBuffer(), UsingImgPropertyStrlist, ",");
		m_ZeroElementRuleItem->SetImgPropertyList(UsingImgPropertyStrlist);
		

		CString sUsingOtherPropertyList;
		nCol = (int)CZeroElementRulesDataTable::ColumnID::S_UsingOtherPropertyList - (int)CZeroElementRulesDataTable::ColumnID::MIN;
		sUsingOtherPropertyList = a_query->GetColStringValue(nCol, _T(""));
		std::vector < std::string> UsingOtherPropertyStrlist;
		xmls::SplitString(sUsingOtherPropertyList.GetBuffer(), UsingOtherPropertyStrlist, ",");
		m_ZeroElementRuleItem->SetOtherpropertyList(UsingOtherPropertyStrlist);


		CString sExpression;
		nCol = (int)CZeroElementRulesDataTable::ColumnID::S_Expression - (int)CZeroElementRulesDataTable::ColumnID::MIN;
		sExpression = a_query->GetColStringValue(nCol, _T(""));
		m_ZeroElementRuleItem->SetExpressionStr(sExpression.GetString());
		return TRUE;
	}
	
#pragma region Region_1
	//CSTDItemPtr CZeroElementRulesDataDB::GetSTDItemById(const long a_nIncAId)
	//{
	//	CSTDItemPtr pSTDItem;

	//	if (!m_listSTDItem.empty())
	//	{
	//		for (auto pItem : m_listSTDItem)
	//		{
	//			if (pItem->GetSTDId() == (DWORD)a_nIncAId)
	//			{
	//				pSTDItem = pItem;
	//			}
	//		}
	//	}
	//	else
	//	{
	//		auto tableQuery = GetQueryById(a_nIncAId);
	//		ASSERT(tableQuery);
	//		if (!tableQuery)
	//		{
	//			return pSTDItem;
	//		}

	//		if (!ReadSTDItem(tableQuery))
	//		{
	//			LogErrorTrace(__FILE__, __LINE__, _T("read x-ray failed."));
	//			return pSTDItem;
	//		}

	//		pSTDItem = CSTDItemPtr(new CSTDItem(*m_pSTDItem.get()));

	//	}

	//	return pSTDItem;
	//}

	//CSTDItemsList& CZeroElementRulesDataDB::GetSTDItemList(const BOOL a_bForce/* = FALSE*/)
	//{
	//	if (a_bForce)
	//	{
	//		m_listSTDItem.clear();
	//	}

	//	if (m_listSTDItem.size() == 0)
	//	{
	//		ReadSTDItemList();
	//	}

	//	return m_listSTDItem;
	//}

	//BOOL CZeroElementRulesDataDB::ReadSTDItemList()
	//{
	//	auto tableInfoPtr = GetTableInfo();
	//	ASSERT(tableInfoPtr);
	//	if (!tableInfoPtr)
	//	{
	//		return FALSE;
	//	}

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

	//	m_listSTDItem = ReadSTDItemList(query);

	//	return TRUE;
	//}

	//CDBQueryBasePtr CZeroElementRulesDataDB::GetQueryById(const long a_nIncAId)
	//{
	//	CDBQueryBasePtr query;
	//	auto datastorePtr = GetDatastore();
	//	ASSERT(datastorePtr);
	//	if (!datastorePtr)
	//	{
	//		return query;
	//	}

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

	//	CString sIncAIdColumnName = tableInfoPtr->GetColumnName((int)CSTDEditorDataTable::ColumnID::N_STDId - (int)CSTDEditorDataTable::ColumnID::MIN);

	//	CString sSQLCommand;
	//	sSQLCommand.Format(_T("SELECT * FROM \'%s\' WHERE %s = %d AND %s = %d;"),
	//		(LPCTSTR)tableInfoPtr->GetTableName(),
	//		(LPCTSTR)sIncAIdColumnName,
	//		a_nIncAId);

	//	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;
	//}
#pragma endregion Region_1
}