#include "StdAfx.h"
#include "KTParamService.h"
#include "KTCurveCreator.h"
#include "KTExpressCalc.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

#define KT_PARAM_DATAFILE	_T("\\KTParamPart.db")

using namespace KTAcadUtl;

ACRX_NO_CONS_DEFINE_MEMBERS(KTParamService, AcRxService)

BOOL KTParamService::RegisterService()
{
	// 检查是否已经注册
	if (Adesk::kTrue == acrxServiceDictionary->has(KT_PARAM_SERVICE))
		return TRUE;

	// 创建服务
	KTParamService* pService = new KTParamService;
	if (NULL == pService)
		return FALSE;

	// 加入服务词典
	BOOL bRegister = (NULL == acrxDynamicLinker->registerService(KT_PARAM_SERVICE, pService));
	if (!bRegister)
		delete pService;

	// 返回状态
	return bRegister;
}

BOOL KTParamService::RemoveService()
{
	// 检查是否已经删除
	if (Adesk::kTrue != acrxServiceDictionary->has(KT_PARAM_SERVICE))
		return TRUE;

	// 从服务词典中移出
	AcRxObject* pObject = acrxServiceDictionary->remove(KT_PARAM_SERVICE);
	ASSERT(NULL != pObject && pObject->isKindOf(KTParamService::desc()));

	// 删除服务
	delete pObject;

	// 已经删除
	return TRUE;
}

KTParamService::KTParamService()
	: m_pParamDatabase(NULL)
{
	SetRuleHandler(_T("Line"), _T("Default"), CreateLineDefault);
	SetRuleHandler(_T("Line"), _T("PtAngLen"), CreateLinePtAngLen);

	SetRuleHandler(_T("Arc"), _T("Default"), CreateArcDefault);
	SetRuleHandler(_T("Arc"), _T("PtPtPt"), CreateArcPtPtPt);
	SetRuleHandler(_T("Arc"), _T("PtPtBulge"), CreateArcPtPtBulge);

	SetRuleHandler(_T("Circle"), _T("Default"), CreateCircleDefault);
	SetRuleHandler(_T("Circle"), _T("PtPtPt"), CreateCirclePtPtPt);
	SetRuleHandler(_T("Circle"), _T("Diameter"), CreateCircleDiameter);

	SetRuleHandler(_T("Ellipse"), _T("Default"), CreateEllipseDefault);
	SetRuleHandler(_T("Ellipse"), _T("PtPtRatio"), CreateEllipsePtPtRatio);

	SetRuleHandler(_T("Text"), _T("Default"), CreateTextDefault);

	SetRuleHandler(_T("Point"), _T("Default"), CreatePointDefault);

	SetRuleHandler(_T("Solid"), _T("Default"), CreateSolidDefault);
	SetRuleHandler(_T("Solid"), _T("PtPtPt"), CreateSolidPtPtPt);

	SetRuleHandler(_T("Cube"), _T("Default"), CreateCubeDefault);
	SetRuleHandler(_T("Cylinder"), _T("Default"), CreateCylinderDefault);
	SetRuleHandler(_T("Cone"), _T("Default"), CreateConeDefault);
	SetRuleHandler(_T("Torus"), _T("Default"), CreateTorusDefault);
	SetRuleHandler(_T("Pipe"), _T("Default"), CreatePipeDefault);
	SetRuleHandler(_T("Duct"), _T("Default"), CreateDuctDefault);
	SetRuleHandler(_T("EccPipeRed"), _T("Default"), CreateEccPipeRedDefault);
	SetRuleHandler(_T("PipeRed"), _T("Default"), CreatePipeRedDefault);
	SetRuleHandler(_T("TrCone"), _T("Default"), CreateTrConeDefault);
	SetRuleHandler(_T("DuctRed"), _T("Default"), CreateDuctRedDefault);
	SetRuleHandler(_T("HemiSph"), _T("Default"), CreateHemiSphDefault);
	SetRuleHandler(_T("Cap"), _T("Default"), CreateCapDefault);
	SetRuleHandler(_T("Tank"), _T("Default"), CreateTankDefault);
}

KTParamService::~KTParamService()
{
	// 清除服务
	ReleaseService();
}

BOOL KTParamService::InitService()
{
	// 检查数据库已经初始化(已经连接到数据库)
	if (NULL != m_pParamDatabase)
		return TRUE;

	// 取得数据库文件路径
	CString sPath;
	if (!KTSetting::GetKTPsPath(sPath))
		return FALSE;

	// 确定路径最后是以\结尾
	if (sPath.Right(1) != _T("\\"))
		sPath += _T('\\');

	// 创建数据库对象
	CUIISQLiteServer* pDatabase = new CUIISQLiteServer;
	if (NULL == pDatabase)
		return FALSE;

	CString dbPath = FilePath::GetSysDir();
	dbPath += KT_PARAM_DATAFILE;
	// 连接数据库文件
	if (!pDatabase->InitADOServer(dbPath))
	{
		delete pDatabase;
		return FALSE;
	}

	// 初始化数据库对象指针
	m_pParamDatabase = pDatabase;

	// 返回成功状态
	return TRUE;
}

BOOL KTParamService::ReleaseService()
{
	// 检查数据库对象已经删除
	if (NULL == m_pParamDatabase)
		return TRUE;

	// 删除数据库对象
	delete m_pParamDatabase;

	// 数据库对象指针置空
	m_pParamDatabase = NULL;

	// 返回成功状态
	return TRUE;
}

RuleHandlerFunPtr KTParamService::GetRuleHandler(LPCTSTR pszCurveType, LPCTSTR pszDrawType) const
{
	ASSERT(NULL != pszCurveType && NULL != pszDrawType);

	CString sText;
	sText.Format(_T("%s_%s"), pszCurveType, pszDrawType);

	RuleHandlerFunPtr pfnHandler = NULL;
	m_mapRuleHandler.Lookup(sText, (void*&)pfnHandler);

	return pfnHandler;
}

BOOL KTParamService::SetRuleHandler(LPCTSTR pszCurveType, LPCTSTR pszDrawType, RuleHandlerFunPtr pfnHandler)
{
	ASSERT(NULL != pszCurveType && NULL != pszDrawType);

	CString sText;
	sText.Format(_T("%s_%s"), pszCurveType, pszDrawType);

	if (NULL == pfnHandler)
	{
		m_mapRuleHandler.RemoveKey(sText);
	}
	else
	{
		m_mapRuleHandler[sText] = pfnHandler;
	}

	return TRUE;
}

BOOL KTParamService::CreateParamPart(AcDbVoidPtrArray& arpPart, const CMapStringToString& mapAttrToValue, LPCTSTR pszPartCode) const
{
	// 获得Id
	KTParamClass data;
	if (!GetClassItemByCode(pszPartCode, data))
		return FALSE;

	// 通过Id创建
	return CreateParamPart(arpPart, mapAttrToValue, data.GetId());
}

BOOL KTParamService::CreateParamPart(AcDbVoidPtrArray& arpPart, const CMapStringToString& mapAttrToValue, ULONG lId) const
{
	CMapStringToString mapDefaultValue;
	return CreateParamPart(arpPart, mapDefaultValue, mapAttrToValue, lId);
}

BOOL KTParamService::CreateParamPart(AcDbVoidPtrArray& arpPart, CMapStringToString& mapDefaultValue, const CMapStringToString& mapAttrToValue, ULONG lId) const
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 获得类数据
	KTParamClass data;
	if (!GetClassItemById(lId, data))
		return FALSE;

	// 创建父类型
	if (0 != data.GetUpId() && !CreateParamPart(arpPart, mapDefaultValue, mapAttrToValue, data.GetUpId()))
		return FALSE;

	// 默认约束参数表达式数据
	LPCTSTR pszVar = data.GetLayer();
	if (NULL != pszVar && _tcslen(pszVar) > 0)
		mapDefaultValue.SetAt(data.GetLayerKey(), pszVar);

	// 取得当前约束数据
	KTParamRulePtrArray arpItems;
	GetRuleItems(lId, arpItems);

	// 取得图元类型描述表
	KTParamTableAttr attribute;
	GetTableAttrItemByField(_T("Rules_Attr"), _T("CurveType"), attribute);
	CString sVarDesc = attribute.GetVarDesc();

	// 创建约束数据
	POSITION pos;
	CStringArray arsTable;
	CString sType, sParam;
	CMapStringToString mapParamToValue, mapFieldToValue, mapParamToType;
	RuleHandlerFunPtr pfnRuleHandle;
	resbuf rbHeader, *pRb;
	AcDbVoidPtrArray arpEnts;
	//
	KTParamRule* pRule;
	int iPos = arpItems.GetSize();
	while ((--iPos) >= 0)
	{
		pRule = arpItems[iPos];
		ASSERT(NULL != pRule);

		// 清空约束参数表达式数据
		mapParamToValue.RemoveAll();

		// 取得约束参数表达式数据
		GetExpressionItemById(pRule->GetId(), mapParamToValue);

		// 添加默认约束参数表达式数据
		pos = mapDefaultValue.GetStartPosition();
		while (NULL != pos)
		{
			mapDefaultValue.GetNextAssoc(pos, sParam, sType);
			if (mapParamToValue[sParam].IsEmpty())
				mapParamToValue.SetAt(sParam, sType);
		}

		// 取得图元类型表
		sType = sVarDesc;
		if (NULL != _tcschr(sVarDesc, _T(' ')))
		{
			mapFieldToValue.RemoveAll();
			pRule->MapFieldToValue(mapFieldToValue);
			if (ExpandSQL(sVarDesc, mapFieldToValue, sParam))
			{
				if (ExecuteSQL(sParam, arsTable))
				{
					sType = arsTable[0];
				}
			}
		}

		// 获得参数类型映射
		mapParamToType.RemoveAll();
		GetCurveDrawTypeParam(sType, pRule->GetCurveType(), pRule->GetDrawType(), mapParamToType, FALSE, FALSE);

		pfnRuleHandle = GetRuleHandler(pRule->GetCurveType(), pRule->GetDrawType());
		if (NULL != pfnRuleHandle)
		{
			rbHeader.rbnext = NULL;
			pRb = &rbHeader;

			pos = mapParamToType.GetStartPosition();
			while (NULL != pos)
			{
				mapParamToType.GetNextAssoc(pos, sParam, sType);
				CreateParamValueResBuf(pRb, sParam, mapParamToValue[sParam], sType, mapAttrToValue);
				while (NULL != pRb->rbnext) pRb = pRb->rbnext;
			}

			arpEnts.setLogicalLength(0);
			pfnRuleHandle(arpEnts, rbHeader.rbnext);
			if (!arpEnts.isEmpty())
				arpPart.append(arpEnts);

			acutRelRb(rbHeader.rbnext);
		}

		delete pRule;
	}

	return TRUE;
}

static BOOL ParamValueCalcProc(LPCTSTR pszVariable, double& dValue, WPARAM wParam, LPARAM lParam)
{
	ASSERT(NULL != lParam);
	CMapStringToString* pMapVar = (CMapStringToString*)lParam;

	CString sValue;
	if (!pMapVar->Lookup(pszVariable, sValue))
	{
		if (_tcsicmp(pszVariable, _T("PI")) == 0)
		{
			dValue = PI;
			return TRUE;
		}
		return FALSE;
	}

	dValue = _tcstod(sValue, NULL);

	return TRUE;
}

BOOL KTParamService::CreateParamValueResBuf(struct resbuf* pRb, LPCTSTR pszParam, LPCTSTR pszValue, LPCTSTR pszType, const CMapStringToString& mapAttrToValue) const
{
	ASSERT(NULL != pRb);

	KTExpressCalc calc;
	calc.SetVariableProc(ParamValueCalcProc, NULL, (LPARAM)&mapAttrToValue);

	if (_tcsicmp(pszType, _T("Char")) == 0)
	{
		CString sValue;

		int i;
		double dVar;
		BOOL bStr = FALSE;
		CString sSub, sVar;
		while (_T('\0') != pszValue[0])
		{
			i = _tcsinc(pszValue) - pszValue;
			if (1 == i)
			{
				switch (pszValue[0])
				{
				case _T('\"'):
					if (bStr)
					{
						ExpandSQL(sSub, mapAttrToValue, sVar);
						sValue += sVar;
						sSub.Empty();
						bStr = FALSE;
					}
					else
					{
						if (!sSub.IsEmpty() && calc.Calculate(sSub, dVar))
							sSub.Format(_T("%g"), dVar);
						sValue += sSub;
						sSub.Empty();
						bStr = TRUE;
					}
					break;
				case _T(','):
					if (bStr)
						sSub += _T(',');
					else
					{
						if (!sSub.IsEmpty() && calc.Calculate(sSub, dVar))
							sSub.Format(_T("%g"), dVar);
						sValue += sSub;
						sValue += _T(',');
						sSub.Empty();
					}
					break;
				case _T('\\'):
					if (_T('\"') == pszValue[1] || _T('\\') == pszValue[1])
					{
						sSub += pszValue[1];
						pszValue++;
					}
					else
					{
						sSub += _T('\\');
					}
					break;
				case _T(' '):
					if (bStr)
						sSub += _T(' ');
					break;
				default:
					sSub += pszValue[0];
					break;
				}
				pszValue++;
			}
			else
			{
				for (; i > 0; i--, pszValue++)
					sSub += pszValue[0];
			}
		}

		if (!sSub.IsEmpty())
		{
			if (bStr)
			{
				ExpandSQL(sSub, mapAttrToValue, sVar);
				sValue += sVar;
			}
			else
			{
				if (calc.Calculate(sSub, dVar))
					sSub.Format(_T("%g"), dVar);
				sValue += sSub;
			}
		}

		pRb->rbnext = acutBuildList(RTSTR, pszParam, RTSTR, (LPCTSTR)sValue, 0);
	}
	else
	{
		double dValue = 0;
		ads_point pt = {0};

		int i, j = 0;
		CString sValue;
		while (_T('\0') != pszValue[0])
		{
			i = _tcsinc(pszValue) - pszValue;
			if (1 == i)
			{
				if (_T(',') == pszValue[0])
				{
					dValue = 0;
					if (!sValue.IsEmpty() && !calc.Calculate(sValue, dValue))
						return FALSE;
					if (j < 3)
						pt[j++] = dValue;
					sValue.Empty();
				}
				else
					sValue += pszValue[0];
				pszValue++;
			}
			else
			{
				for (; i > 0; i--, pszValue++)
					sValue += pszValue[0];
			}
		}

		if (!sValue.IsEmpty())
		{
			dValue = 0;
			if (!calc.Calculate(sValue, dValue))
				return FALSE;
			if (j < 3) 
				pt[j] = dValue;
		}

		if (_tcsicmp(pszType, _T("Int")) == 0 || _tcsicmp(pszType, _T("Bool")) == 0)
			pRb->rbnext = acutBuildList(RTSTR, pszParam, RTLONG, long(dValue + 0.5), 0);
		else if (_tcsicmp(pszType, _T("Point")) == 0)
			pRb->rbnext = acutBuildList(RTSTR, pszParam, RT3DPOINT, pt, 0);
		else
			pRb->rbnext = acutBuildList(RTSTR, pszParam, RTREAL, dValue, 0);
	}

	return TRUE;
}

BOOL KTParamService::GetAccessSQL(LPCTSTR pszAccess, CString& sSQL, CString& sFlags) const
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 构建SQL语句
	CString sAccess;
	sAccess.Format(_T("Select [SQL], [Flags] From [AccessSQL] Where [KEY]=\'%s\' Order By [Index]"), pszAccess);

	// 获得数据
	CUIIValueTable vTable;
	int iRows = m_pParamDatabase->GetSelData(sAccess, vTable);

	// 获得操作SQL语句
	sSQL.Empty();
	sFlags.Empty();
	for (int i = 0; i < iRows; i++)
	{
		// 取得数据
		CStringArray arsValue;
		vTable.GetValueRecord(i, arsValue);

		// 将多条数据合并
		ASSERT(arsValue.GetSize() > 1);
		sSQL += arsValue[0];
		sFlags += arsValue[1];
	}

	// 返回状态
	return (iRows > 0);
}

BOOL KTParamService::ExpandSQL(LPCTSTR pszSQLExpress, const CMapStringToString& mapVarToValue, CString& sSQL) const
{
	BOOL bVar = FALSE;
	CString sExpand, sVar, sValue;
	while (_T('\0') != pszSQLExpress[0])
	{
		int i = _tcsinc(pszSQLExpress) - pszSQLExpress;
		if (1 == i)
		{
			if (bVar)
			{
				if (_istalnum(pszSQLExpress[0]) || _T('_') == pszSQLExpress[0])
					sVar += pszSQLExpress[0];
				else
				{
					if (!mapVarToValue.Lookup(sVar, sValue))
						return FALSE;
					bVar = FALSE;
					sVar.Empty();
					sExpand += sValue;
					sExpand += pszSQLExpress[0];
				}
			}
			else
			{
				if (_T('$') == pszSQLExpress[0])
				{
					if (_T('$') == pszSQLExpress[1])
					{
						sExpand += _T('$');
						pszSQLExpress++;
					}
					else
					{
						bVar = TRUE;
					}
				}
				else
				{
					sExpand += pszSQLExpress[0];
				}
			}
			pszSQLExpress++;
		}
		else
		{
			for (; i > 0; i--, pszSQLExpress++)
			{
				(bVar ? sVar : sExpand) += pszSQLExpress[0];
			}
		}
	}

	if (bVar && !sVar.IsEmpty())
	{
		if (!mapVarToValue.Lookup(sVar, sValue))
			return FALSE;
		sExpand += sValue;
	}

	sSQL = sExpand;

	return (!sSQL.IsEmpty());
}

BOOL KTParamService::ExecuteSQL(LPCTSTR pszSQL, CStringArray& arsItems) const
{
	ASSERT(NULL != pszSQL && 0 < _tcslen(pszSQL));

	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	int iLen;
	CString sSub;
	LPCTSTR pszSub;
	CString sResult;
	while (NULL != (pszSub = _tcschr(pszSQL, _T(';'))))
	{
		iLen = pszSub - pszSQL;
		_tcsncpy(sSub.GetBuffer(iLen), pszSQL, iLen);
		sSub.ReleaseBuffer();

		if (!sResult.IsEmpty())
			sSub.Replace(_T("#"), sResult);

		if (sSub.Find(_T("#")) >= 0)
			return FALSE;

		if (m_pParamDatabase->GetSelData(sSub, arsItems) > 0 && (iLen = arsItems.GetSize()) > 0)
			sResult = arsItems[iLen-1];

		arsItems.RemoveAll();
		pszSQL = pszSub + 1;
	}

	sSub = pszSQL;
	if (!sResult.IsEmpty())
		sSub.Replace(_T("#"), sResult);

	if (sSub.Find(_T("#")) >= 0)
		return FALSE;

	m_pParamDatabase->GetSelData(sSub, arsItems);

	return (arsItems.GetSize() > 0);
}

BOOL KTParamService::GetTableItemById(LPCTSTR pszSQLKey, ULONG lId, CMapStringToString& mapFieldToValue) const
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得操作SQL语句,检查参数合法性
	CString sSQL, sFlags;
	GetAccessSQL(pszSQLKey, sSQL, sFlags);
	if (sFlags.GetLength() != 1 || _T('N') != sFlags[0])
		return FALSE;

	// 构造完整SQL语句
	CString sAccess;
	sAccess.Format(sSQL, lId);

	// 返回状态
	return (m_pParamDatabase->GetSelDataEx(sAccess, mapFieldToValue) > 0);
}

BOOL KTParamService::GetTableAttrItems(LPCTSTR pszTable, BOOL bOnlyVisible, KTParamTableAttrPtrArray& arpItems) const
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得操作SQL语句,检查参数合法性
	CString sSQL, sFlags;
	GetAccessSQL((bOnlyVisible ? _T("GetTableShowAttrs") : _T("GetTableAttrItems")), sSQL, sFlags);
	if (sFlags.GetLength() != 1 || _T('C') != sFlags[0])
		return FALSE;

	// 构造完整SQL语句
	CString sAccess;
	sAccess.Format(sSQL, pszTable);

	// 获得数据
	CUIIValueTable vTable;
	int iRows = m_pParamDatabase->GetSelData(sAccess, vTable);

	// 获得所有数据条目
	CString sValue;
	KTParamTableAttr* pData;
	for (int i = 0; i < iRows; i++)
	{
		// 创建数据对象
		pData = new KTParamTableAttr;
		if (NULL == pData)
			continue;

		// 取得数据
		CUIIValueRecord vRecord;
		vTable.GetValueRecord(i, vRecord);

		// 将数据导入对象中
		ASSERT(vRecord.GetLableLogicSize() > 14);
		vRecord.GetValue(0, sValue);
		pData->SetId(_ttol(sValue));

		vRecord.GetValue(1, sValue);
		pData->SetField(sValue);

		vRecord.GetValue(2, sValue);
		pData->SetName(sValue);

		vRecord.GetValue(3, sValue);
		pData->SetDesc(sValue);

		vRecord.GetValue(4, sValue);
		pData->SetDataType(sValue);

		vRecord.GetValue(5, sValue);
		pData->SetValue(sValue);

		vRecord.GetValue(6, sValue);
		pData->SetDefault(sValue);

		vRecord.GetValue(7, sValue);
		pData->SetVarDesc(sValue);

		vRecord.GetValue(8, sValue);
		pData->SetNotNull(_ttoi(sValue));

		vRecord.GetValue(9, sValue);
		pData->SetVisible(_ttoi(sValue));

		vRecord.GetValue(10, sValue);
		pData->SetOverride(_ttoi(sValue));

		vRecord.GetValue(11, sValue);
		pData->SetReadOnly(_ttoi(sValue));

		vRecord.GetValue(12, sValue);
		pData->SetNeedSave(_ttoi(sValue));

		vRecord.GetValue(13, sValue);
		pData->SetIndex(_ttol(sValue));

		vRecord.GetValue(14, sValue);
		pData->SetFlags(sValue);

		// 添加到数组中
		arpItems.Add(pData);
	}

	// 返回状态
	return (iRows > 0);
}

BOOL KTParamService::GetTableAttrItemByField(LPCTSTR pszTable, LPCTSTR pszFiled, KTParamTableAttr& data) const
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得操作SQL语句,检查参数合法性
	CString sSQL, sFlags;
	GetAccessSQL(_T("GetTableAttrItemByField"), sSQL, sFlags);
	if (sFlags.GetLength() != 2 || _T('C') != sFlags[0] || _T('C') != sFlags[1])
		return FALSE;

	// 构造完整SQL语句
	CString sAccess;
	sAccess.Format(sSQL, pszTable, pszFiled);

	// 获得数据
	CString sValue;
	CUIIValueTable vTable;
	int iRows = m_pParamDatabase->GetSelData(sAccess, vTable);
	ASSERT(iRows <= 1);
	if (iRows > 0)
	{
		// 取得数据
		CUIIValueRecord vRecord;
		vTable.GetValueRecord(0, vRecord);

		// 将数据导入对象中
		ASSERT(vRecord.GetLableLogicSize() > 14);
		vRecord.GetValue(0, sValue);
		data.SetId(_ttol(sValue));

		vRecord.GetValue(1, sValue);
		data.SetField(sValue);

		vRecord.GetValue(2, sValue);
		data.SetName(sValue);

		vRecord.GetValue(3, sValue);
		data.SetDesc(sValue);

		vRecord.GetValue(4, sValue);
		data.SetDataType(sValue);

		vRecord.GetValue(5, sValue);
		data.SetValue(sValue);

		vRecord.GetValue(6, sValue);
		data.SetDefault(sValue);

		vRecord.GetValue(7, sValue);
		data.SetVarDesc(sValue);

		vRecord.GetValue(8, sValue);
		data.SetNotNull(_ttoi(sValue));

		vRecord.GetValue(9, sValue);
		data.SetVisible(_ttoi(sValue));

		vRecord.GetValue(10, sValue);
		data.SetOverride(_ttoi(sValue));

		vRecord.GetValue(11, sValue);
		data.SetReadOnly(_ttoi(sValue));

		vRecord.GetValue(12, sValue);
		data.SetNeedSave(_ttoi(sValue));

		vRecord.GetValue(13, sValue);
		data.SetIndex(_ttol(sValue));

		vRecord.GetValue(14, sValue);
		data.SetFlags(sValue);
	}

	// 返回状态
	return (iRows > 0);
}

BOOL KTParamService::GetTableMapItems(LPCTSTR pszTable, LPCTSTR pszField1, LPCTSTR pszField2, CMapStringToString& mapItems) const
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得操作SQL语句,检查参数合法性
	CString sSQL, sFlags;
	GetAccessSQL(_T("GetTableMapItems"), sSQL, sFlags);
	if (sFlags.GetLength() != 3 || _T('C') != sFlags[0] || _T('C') != sFlags[1] || _T('C') != sFlags[2])
		return FALSE;

	// 构造完整SQL语句
	CString sAccess;
	sAccess.Format(sSQL, pszField1, pszField2, pszTable);

	// 返回状态
	return (m_pParamDatabase->GetSelData(sAccess, mapItems) > 0);
}

BOOL KTParamService::GetTableFieldItems(LPCTSTR pszTable, LPCTSTR pszField, CStringArray& arsValue) const
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得操作SQL语句,检查参数合法性
	CString sSQL, sFlags;
	GetAccessSQL(_T("GetTableFieldItems"), sSQL, sFlags);
	if (sFlags.GetLength() != 2 || _T('C') != sFlags[0] || _T('C') != sFlags[1])
		return FALSE;

	// 构造完整SQL语句
	CString sAccess;
	sAccess.Format(sSQL, pszField, pszTable);

	// 返回状态
	return (m_pParamDatabase->GetSelData(sAccess, arsValue) > 0);
}

BOOL KTParamService::GetSubClassItems(ULONG lParentId, KTParamClassArray& arItems) const
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得操作SQL语句,检查参数合法性
	CString sSQL, sFlags;
	GetAccessSQL(_T("GetSubClassItems"), sSQL, sFlags);
	if (sFlags.GetLength() != 1 || _T('N') != sFlags[0])
		return FALSE;

	// 构造完整SQL语句
	CString sAccess;
	sAccess.Format(sSQL, lParentId);

	// 获得数据
	CUIIValueTable vTable;
	int iRows = m_pParamDatabase->GetSelData(sAccess, vTable);

	// 获得所有数据条目
	CString sValue;
	KTParamClass data;
	for (int i = 0; i < iRows; i++)
	{
		// 取得数据
		CUIIValueRecord vRecord;
		vTable.GetValueRecord(i, vRecord);

		// 将数据导入对象中
		ASSERT(vRecord.GetLableLogicSize() > 9);
		vRecord.GetValue(0, sValue);
		data.SetId(_ttol(sValue));

		vRecord.GetValue(1, sValue);
		data.SetUpId(_ttol(sValue));

		vRecord.GetValue(2, sValue);
		data.SetCode(sValue);

		vRecord.GetValue(3, sValue);
		data.SetName(sValue);

		vRecord.GetValue(4, sValue);
		data.SetDesc(sValue);

		vRecord.GetValue(5, sValue);
		data.SetIcon1(sValue);

		vRecord.GetValue(6, sValue);
		data.SetIcon2(sValue);

		vRecord.GetValue(7, sValue);
		data.SetReadOnly(_ttoi(sValue));

		vRecord.GetValue(8, sValue);
		data.SetFlags(sValue);

		vRecord.GetValue(9, sValue);
		data.SetLayer(sValue);

		// 添加到数组中
		arItems.Add(data);
	}

	// 返回状态
	return (iRows > 0);
}

BOOL KTParamService::GetClassItemById(ULONG lId, KTParamClass& data) const
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得操作SQL语句,检查参数合法性
	CString sSQL, sFlags;
	GetAccessSQL(_T("GetClassItemById"), sSQL, sFlags);
	if (sFlags.GetLength() != 1 || _T('N') != sFlags[0])
		return FALSE;

	// 构造完整SQL语句
	CString sAccess;
	sAccess.Format(sSQL, lId);

	// 获得数据
	CString sValue;
	CUIIValueTable vTable;
	int iRows = m_pParamDatabase->GetSelData(sAccess, vTable);
	ASSERT(iRows <= 1);
	if (iRows > 0)
	{
		// 取得数据
		CUIIValueRecord vRecord;
		vTable.GetValueRecord(0, vRecord);

		// 将数据导入对象中
		ASSERT(vRecord.GetLableLogicSize() > 9);
		vRecord.GetValue(0, sValue);
		data.SetId(_ttol(sValue));

		vRecord.GetValue(1, sValue);
		data.SetUpId(_ttol(sValue));

		vRecord.GetValue(2, sValue);
		data.SetCode(sValue);

		vRecord.GetValue(3, sValue);
		data.SetName(sValue);

		vRecord.GetValue(4, sValue);
		data.SetDesc(sValue);

		vRecord.GetValue(5, sValue);
		data.SetIcon1(sValue);

		vRecord.GetValue(6, sValue);
		data.SetIcon2(sValue);

		vRecord.GetValue(7, sValue);
		data.SetReadOnly(_ttoi(sValue));

		vRecord.GetValue(8, sValue);
		data.SetFlags(sValue);

		vRecord.GetValue(9, sValue);
		data.SetLayer(sValue);
	}

	// 返回状态
	return (iRows > 0);
}

BOOL KTParamService::GetClassItemByCode(LPCTSTR pszCode, KTParamClass& data) const
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得操作SQL语句,检查参数合法性
	CString sSQL, sFlags;
	GetAccessSQL(_T("GetClassItemByCode"), sSQL, sFlags);
	if (sFlags.GetLength() != 1 || _T('C') != sFlags[0])
		return FALSE;

	// 构造完整SQL语句
	CString sAccess;
	sAccess.Format(sSQL, pszCode);

	// 获得数据
	CString sValue;
	CUIIValueTable vTable;
	int iRows = m_pParamDatabase->GetSelData(sAccess, vTable);
	ASSERT(iRows <= 1);
	if (iRows > 0)
	{
		// 取得数据
		CUIIValueRecord vRecord;
		vTable.GetValueRecord(0, vRecord);

		// 将数据导入对象中
		ASSERT(vRecord.GetLableLogicSize() > 9);
		vRecord.GetValue(0, sValue);
		data.SetId(_ttol(sValue));

		vRecord.GetValue(1, sValue);
		data.SetUpId(_ttol(sValue));

		vRecord.GetValue(2, sValue);
		data.SetCode(sValue);

		vRecord.GetValue(3, sValue);
		data.SetName(sValue);

		vRecord.GetValue(4, sValue);
		data.SetDesc(sValue);

		vRecord.GetValue(5, sValue);
		data.SetIcon1(sValue);

		vRecord.GetValue(6, sValue);
		data.SetIcon2(sValue);

		vRecord.GetValue(7, sValue);
		data.SetReadOnly(_ttoi(sValue));

		vRecord.GetValue(8, sValue);
		data.SetFlags(sValue);

		vRecord.GetValue(9, sValue);
		data.SetLayer(sValue);
	}

	// 返回状态
	return (iRows > 0);
}

BOOL KTParamService::HasSameClassCode(LPCTSTR pszCode, ULONG lExceptId) const
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得操作SQL语句,检查参数合法性
	CString sSQL, sFlags;
	GetAccessSQL(_T("HasSameClassCode"), sSQL, sFlags);
	if (sFlags.GetLength() != 2 || sFlags.CompareNoCase(_T("CN")) != 0)
		return FALSE;

	// 构造完整SQL语句
	CString sAccess;
	sAccess.Format(sSQL, pszCode, lExceptId);

	// 获得数据
	return (!m_pParamDatabase->IsSelEmpty(sAccess));
}

BOOL KTParamService::GetAttributeItems(ULONG lClassId, KTParamAttributeArray& arItems) const
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得操作SQL语句,检查参数合法性
	CString sSQL, sFlags;
	GetAccessSQL(_T("GetAttributeItems"), sSQL, sFlags);
	if (sFlags.GetLength() != 1 || _T('N') != sFlags[0])
		return FALSE;

	// 构造完整SQL语句
	CString sAccess;
	sAccess.Format(sSQL, lClassId);

	// 获得数据
	CUIIValueTable vTable;
	int iRows = m_pParamDatabase->GetSelData(sAccess, vTable);

	// 获得所有数据条目
	CString sValue;
	KTParamAttribute cData;
	for (int i = 0; i < iRows; i++)
	{
		// 取得数据
		CUIIValueRecord vRecord;
		vTable.GetValueRecord(i, vRecord);

		// 将数据导入对象中
		ASSERT(vRecord.GetLableLogicSize() > 15);
		vRecord.GetValue(0, sValue);
		cData.SetId(_ttol(sValue));

		vRecord.GetValue(1, sValue);
		cData.SetClassId(_ttol(sValue));

		vRecord.GetValue(2, sValue);
		cData.SetCode(sValue);

		vRecord.GetValue(3, sValue);
		cData.SetName(sValue);

		vRecord.GetValue(4, sValue);
		cData.SetDesc(sValue);

		vRecord.GetValue(5, sValue);
		cData.SetDataType(sValue);

		vRecord.GetValue(6, sValue);
		cData.SetValue(sValue);

		vRecord.GetValue(7, sValue);
		cData.SetDefault(sValue);

		vRecord.GetValue(8, sValue);
		cData.SetVarDesc(sValue);

		vRecord.GetValue(9, sValue);
		cData.SetNotNull(_ttoi(sValue));

		vRecord.GetValue(10, sValue);
		cData.SetVisible(_ttoi(sValue));

		vRecord.GetValue(11, sValue);
		cData.SetOverride(_ttoi(sValue));

		vRecord.GetValue(12, sValue);
		cData.SetReadOnly(_ttoi(sValue));

		vRecord.GetValue(13, sValue);
		cData.SetNeedSave(_ttoi(sValue));

		vRecord.GetValue(14, sValue);
		cData.SetIndex(_ttol(sValue));

		vRecord.GetValue(15, sValue);
		cData.SetFlags(sValue);

		// 添加到数组中
		arItems.Add(cData);
	}

	// 返回状态
	return (iRows > 0);
}

BOOL KTParamService::GetAttributeItems(ULONG lClassId, KTParamAttributePtrArray& arpItems) const
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得操作SQL语句,检查参数合法性
	CString sSQL, sFlags;
	GetAccessSQL(_T("GetAttributeItems"), sSQL, sFlags);
	if (sFlags.GetLength() != 1 || _T('N') != sFlags[0])
		return FALSE;

	// 构造完整SQL语句
	CString sAccess;
	sAccess.Format(sSQL, lClassId);

	// 获得数据
	CUIIValueTable vTable;
	int iRows = m_pParamDatabase->GetSelData(sAccess, vTable);

	// 获得所有数据条目
	CString sValue;
	KTParamAttribute* pData;
	for (int i = 0; i < iRows; i++)
	{
		// 创建数据对象
		pData = new KTParamAttribute;
		if (NULL == pData)
			continue;

		// 取得数据
		CUIIValueRecord vRecord;
		vTable.GetValueRecord(i, vRecord);

		// 将数据导入对象中
		ASSERT(vRecord.GetLableLogicSize() > 15);
		vRecord.GetValue(0, sValue);
		pData->SetId(_ttol(sValue));

		vRecord.GetValue(1, sValue);
		pData->SetClassId(_ttol(sValue));

		vRecord.GetValue(2, sValue);
		pData->SetCode(sValue);

		vRecord.GetValue(3, sValue);
		pData->SetName(sValue);

		vRecord.GetValue(4, sValue);
		pData->SetDesc(sValue);

		vRecord.GetValue(5, sValue);
		pData->SetDataType(sValue);

		vRecord.GetValue(6, sValue);
		pData->SetValue(sValue);

		vRecord.GetValue(7, sValue);
		pData->SetDefault(sValue);

		vRecord.GetValue(8, sValue);
		pData->SetVarDesc(sValue);

		vRecord.GetValue(9, sValue);
		pData->SetNotNull(_ttoi(sValue));

		vRecord.GetValue(10, sValue);
		pData->SetVisible(_ttoi(sValue));

		vRecord.GetValue(11, sValue);
		pData->SetOverride(_ttoi(sValue));

		vRecord.GetValue(12, sValue);
		pData->SetReadOnly(_ttoi(sValue));

		vRecord.GetValue(13, sValue);
		pData->SetNeedSave(_ttoi(sValue));

		vRecord.GetValue(14, sValue);
		pData->SetIndex(_ttol(sValue));

		vRecord.GetValue(15, sValue);
		pData->SetFlags(sValue);

		// 添加到数组中
		arpItems.Add(pData);
	}

	// 返回状态
	return (iRows > 0);
}

BOOL KTParamService::GetRuleItems(ULONG lClassId, KTParamRuleArray& arItems) const
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得操作SQL语句,检查参数合法性
	CString sSQL, sFlags;
	GetAccessSQL(_T("GetRuleItems"), sSQL, sFlags);
	if (sFlags.GetLength() != 1 || _T('N') != sFlags[0])
		return FALSE;

	// 构造完整SQL语句
	CString sAccess;
	sAccess.Format(sSQL, lClassId);

	// 获得数据
	CUIIValueTable vTable;
	int iRows = m_pParamDatabase->GetSelData(sAccess, vTable);

	// 获得所有数据条目
	CString sValue;
	KTParamRule cData;
	for (int i = 0; i < iRows; i++)
	{
		// 取得数据
		CUIIValueRecord vRecord;
		vTable.GetValueRecord(i, vRecord);

		// 将数据导入对象中
		ASSERT(vRecord.GetLableLogicSize() > 5);
		vRecord.GetValue(0, sValue);
		cData.SetId(_ttol(sValue));

		vRecord.GetValue(1, sValue);
		cData.SetClassId(_ttol(sValue));

		vRecord.GetValue(2, sValue);
		cData.SetCurveType(sValue);

		vRecord.GetValue(3, sValue);
		cData.SetDrawType(sValue);

		vRecord.GetValue(4, sValue);
		cData.SetIndex(_ttol(sValue));

		vRecord.GetValue(5, sValue);
		cData.SetFlags(sValue);

		// 添加到数组中
		arItems.Add(cData);
	}

	// 返回状态
	return (iRows > 0);
}

BOOL KTParamService::GetRuleItems(ULONG lClassId, KTParamRulePtrArray& arpItems) const
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得操作SQL语句,检查参数合法性
	CString sSQL, sFlags;
	GetAccessSQL(_T("GetRuleItems"), sSQL, sFlags);
	if (sFlags.GetLength() != 1 || _T('N') != sFlags[0])
		return FALSE;

	// 构造完整SQL语句
	CString sAccess;
	sAccess.Format(sSQL, lClassId);

	// 获得数据
	CUIIValueTable vTable;
	int iRows = m_pParamDatabase->GetSelData(sAccess, vTable);

	// 获得所有数据条目
	CString sValue;
	KTParamRule* pData;
	for (int i = 0; i < iRows; i++)
	{
		// 创建数据对象
		pData = new KTParamRule;
		if (NULL == pData)
			continue;

		// 取得数据
		CUIIValueRecord vRecord;
		vTable.GetValueRecord(i, vRecord);

		// 将数据导入对象中
		ASSERT(vRecord.GetLableLogicSize() > 5);
		vRecord.GetValue(0, sValue);
		pData->SetId(_ttol(sValue));

		vRecord.GetValue(1, sValue);
		pData->SetClassId(_ttol(sValue));

		vRecord.GetValue(2, sValue);
		pData->SetCurveType(sValue);

		vRecord.GetValue(3, sValue);
		pData->SetDrawType(sValue);

		vRecord.GetValue(4, sValue);
		pData->SetIndex(_ttol(sValue));

		vRecord.GetValue(5, sValue);
		pData->SetFlags(sValue);

		// 添加到数组中
		arpItems.Add(pData);
	}

	// 返回状态
	return (iRows > 0);
}

BOOL KTParamService::GetRuleItemIds(ULONG lClassId, CStringArray& arsItemIds) const
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得操作SQL语句,检查参数合法性
	CString sSQL, sFlags;
	GetAccessSQL(_T("GetRuleItemIds"), sSQL, sFlags);
	if (sFlags.GetLength() != 1 || _T('N') != sFlags[0])
		return FALSE;

	// 构造完整SQL语句
	CString sAccess;
	sAccess.Format(sSQL, lClassId);

	// 获得数据
	return (m_pParamDatabase->GetSelData(sAccess, arsItemIds) > 0);
}

BOOL KTParamService::GetExpressionItems(ULONG lRuleId, KTParamExpressionArray& arItems) const
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得操作SQL语句,检查参数合法性
	CString sSQL, sFlags;
	GetAccessSQL(_T("GetExpressionItems"), sSQL, sFlags);
	if (sFlags.GetLength() != 1 || _T('N') != sFlags[0])
		return FALSE;

	// 构造完整SQL语句
	CString sAccess;
	sAccess.Format(sSQL, lRuleId);

	// 获得数据
	CUIIValueTable vTable;
	int iRows = m_pParamDatabase->GetSelData(sAccess, vTable);

	// 获得所有数据条目
	CString sValue;
	KTParamExpression data;
	for (int i = 0; i < iRows; i++)
	{
		// 取得数据
		CUIIValueRecord vRecord;
		vTable.GetValueRecord(i, vRecord);

		// 将数据导入对象中
		ASSERT(vRecord.GetLableLogicSize() > 5);
		vRecord.GetValue(0, sValue);
		data.SetId(_ttol(sValue));

		vRecord.GetValue(1, sValue);
		data.SetRuleId(_ttol(sValue));

		vRecord.GetValue(2, sValue);
		data.SetVarType(sValue);

		vRecord.GetValue(3, sValue);
		data.SetValue(sValue);

		vRecord.GetValue(4, sValue);
		data.SetIndex(_ttol(sValue));

		vRecord.GetValue(5, sValue);
		data.SetFlags(sValue);

		// 添加到数组中
		arItems.Add(data);
	}

	// 返回状态
	return (iRows > 0);
}

BOOL KTParamService::GetExpressionItemById(ULONG lRuleId, CMapStringToString& mapVarTypeToValue) const
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得操作SQL语句,检查参数合法性
	CString sSQL, sFlags;
	GetAccessSQL(_T("GetExpressionItemById"), sSQL, sFlags);
	if (sFlags.GetLength() != 1 || _T('N') != sFlags[0])
		return FALSE;

	// 构造完整SQL语句
	CString sAccess;
	sAccess.Format(sSQL, lRuleId);

	// 获得数据
	return (m_pParamDatabase->GetSelData(sAccess, mapVarTypeToValue) > 0);
}

BOOL KTParamService::GetCurveDrawTypeParam(LPCTSTR pszCurveTable, LPCTSTR pszCurveType, LPCTSTR pszDrawType, CMapStringToString& mapParamToDesc, BOOL bRev, BOOL bDesc) const
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得操作SQL语句,检查参数合法性
	CString sSQL, sFlags;
	GetAccessSQL(_T("GetSubTypeTable"), sSQL, sFlags);
	if (sFlags.GetLength() != 2 || _T('C') != sFlags[0] || _T('C') != sFlags[1])
		return FALSE;

	// 构造完整SQL语句
	CString sAccess;
	sAccess.Format(sSQL, pszCurveTable, pszCurveType);

	// 获得绘制类型数据表
	CString sTable;
	m_pParamDatabase->GetSelData(sAccess, sTable);
	if (sTable.IsEmpty())
		return FALSE;

	// 获得参数表
	sAccess.Format(sSQL, sTable, pszDrawType);
	m_pParamDatabase->GetSelData(sAccess, sTable);

	if (bDesc)
		return (bRev ? GetDescToValueMap(sTable, mapParamToDesc) : GetValueToDescMap(sTable, mapParamToDesc));
	else
		return (bRev ? GetTypeToValueMap(sTable, mapParamToDesc) : GetValueToTypeMap(sTable, mapParamToDesc));
}

BOOL KTParamService::UpdateClassData(KTParamClass* pData)
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得操作SQL语句,检查参数合法性
	CString sSQL, sFlags;
	GetAccessSQL(_T("GetClassItemIdById"), sSQL, sFlags);
	if (sFlags.GetLength() != 1 || _T('N') != sFlags[0])
		return FALSE;

	// 构造完整SQL语句
	CString sAccess;
	sAccess.Format(sSQL, pData->GetId());

	// 判断是否存在
	if (m_pParamDatabase->IsSelEmpty(sAccess))
	{
		// 取得操作SQL语句,检查参数合法性
		GetAccessSQL(_T("InsertClassItem"), sSQL, sFlags);
		if (sFlags.GetLength() != 3 || sFlags.CompareNoCase(_T("NC7")) != 0)
			return FALSE;

		// 构造完整SQL语句
		sAccess.Format(sSQL, pData->GetUpId(), pData->GetCode(), pData->GetName(), pData->GetDesc(),
						pData->GetIcon1(), pData->GetIcon2(), BoolToString(pData->IsReadOnly()),
						pData->GetFlags(), pData->GetLayer());

		// 插入数据
		m_pParamDatabase->ExecuteSQL(sAccess);

		// 取得操作SQL语句,检查参数合法性
		GetAccessSQL(_T("GetClassItemIdByUpIdCode"), sSQL, sFlags);
		if (sFlags.GetLength() != 2 || sFlags.CompareNoCase(_T("NC")) != 0)
			return FALSE;

		// 构造完整SQL语句
		sAccess.Format(sSQL, pData->GetUpId(), pData->GetCode());

		// 取得插入后的ID
		if (m_pParamDatabase->GetSelData(sAccess, sFlags) <= 0)
			return FALSE;

		pData->SetId(StringToLong(sFlags));

		return (pData->GetId() > 0);
	}
	else
	{
		// 取得操作SQL语句,检查参数合法性
		GetAccessSQL(_T("UpdateClassItemById"), sSQL, sFlags);
		if (sFlags.GetLength() != 4 || sFlags.CompareNoCase(_T("NC7N")) != 0)
			return FALSE;

		// 构造完整SQL语句
		sAccess.Format(sSQL, pData->GetUpId(), pData->GetCode(), pData->GetName(), pData->GetDesc(),
						pData->GetIcon1(), pData->GetIcon2(), BoolToString(pData->IsReadOnly()),
						pData->GetFlags(), pData->GetLayer(), pData->GetId());

		// 更新数据
		return m_pParamDatabase->ExecuteSQL(sAccess);
	}
}

BOOL KTParamService::UpdateAttributeData(ULONG lClassId, KTParamAttributePtrArray& arpData)
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得更新操作SQL语句,检查参数合法性
	CString sUpdateSQL, sFlags;
	GetAccessSQL(_T("UpdateAttrItemById"), sUpdateSQL, sFlags);
	if (sFlags.GetLength() != 7 || sFlags.CompareNoCase(_T("NC12NCN")) != 0)
		return FALSE;

	// 取得插入操作SQL语句,检查参数合法性
	CString sInsertSQL;
	GetAccessSQL(_T("InsertAttrItem"), sInsertSQL, sFlags);
	if (sFlags.GetLength() != 6 || sFlags.CompareNoCase(_T("NC12NC")) != 0)
		return FALSE;

	// 取得删除操作SQL语句,检查参数合法性
	CString sDeleteSQL;
	GetAccessSQL(_T("DeleteAttrItemById"), sDeleteSQL, sFlags);
	if (sFlags.GetLength() != 1 || _T('N') != sFlags[0])
		return FALSE;

	KTParamAttributeArray arItems;
	GetAttributeItems(lClassId, arItems);

	CString sAccess;
	KTParamAttribute* pOld;
	KTParamAttribute* pData;
	int iIndex, iSize = arpData.GetSize();
	for (int i = 0; i < iSize; i++)
	{
		pData = arpData[i];
		ASSERT(NULL != pData);

		if ((iIndex = arItems.GetSize() - 1) >= 0)
		{
			pOld = &(arItems[iIndex]);
			arItems.RemoveAt(iIndex);

			// 构造完整SQL语句
			sAccess.Format(sUpdateSQL, lClassId, pData->GetCode(), pData->GetName(), pData->GetDesc(),
							pData->GetDataType(), pData->GetValue(), pData->GetDefault(), pData->GetVarDesc(),
							BoolToString(pData->IsNotNull()), BoolToString(pData->IsVisible()),
							BoolToString(pData->IsOverride()), BoolToString(pData->IsReadOnly()),
							BoolToString(pData->IsNeedSave()), pData->GetIndex(), pData->GetFlags(),
							pOld->GetId());

			// 更新数据
			m_pParamDatabase->ExecuteSQL(sAccess);
		}
		else
		{
			// 构造完整SQL语句
			sAccess.Format(sInsertSQL, lClassId, pData->GetCode(), pData->GetName(), pData->GetDesc(),
							pData->GetDataType(), pData->GetValue(), pData->GetDefault(), pData->GetVarDesc(),
							BoolToString(pData->IsNotNull()), BoolToString(pData->IsVisible()),
							BoolToString(pData->IsOverride()), BoolToString(pData->IsReadOnly()),
							BoolToString(pData->IsNeedSave()), pData->GetIndex(), pData->GetFlags());

			// 插入数据
			m_pParamDatabase->ExecuteSQL(sAccess);
		}
	}

	// 删除原有多余的属性数据
	iIndex = arItems.GetSize();
	while ((--iIndex) >= 0)
	{
		pOld = &(arItems[iIndex]);

		// 构造完整SQL语句
		sAccess.Format(sDeleteSQL, pOld->GetId());

		// 删除数据
		m_pParamDatabase->ExecuteSQL(sAccess);
	}

	return TRUE;
}

BOOL KTParamService::UpdateRuleData(ULONG lClassId, KTParamRulePtrArray& arpData)
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得更新操作SQL语句,检查参数合法性
	CString sUpdateSQL, sFlags;
	GetAccessSQL(_T("UpdateRuleById"), sUpdateSQL, sFlags);
	if (sFlags.GetLength() != 6 || sFlags.CompareNoCase(_T("NCCNCN")) != 0)
		return FALSE;

	// 取得插入操作SQL语句,检查参数合法性
	CString sInsertSQL;
	GetAccessSQL(_T("InsertRuleItem"), sInsertSQL, sFlags);
	if (sFlags.GetLength() != 5 || sFlags.CompareNoCase(_T("NCCNC")) != 0)
		return FALSE;

	// 取得删除操作SQL语句,检查参数合法性
	CString sDeleteSQL;
	GetAccessSQL(_T("DeleteRuleById"), sDeleteSQL, sFlags);
	if (sFlags.GetLength() != 1 || _T('N') != sFlags[0])
		return FALSE;

	// 取得操作SQL语句,检查参数合法性
	CString sGetDataSQL;
	GetAccessSQL(_T("GetRuleItemIdByClsIdIdx"), sGetDataSQL, sFlags);
	if (sFlags.GetLength() != 2 || sFlags.CompareNoCase(_T("NN")) != 0)
		return FALSE;

	KTParamRuleArray arItems;
	GetRuleItems(lClassId, arItems);

	CString sAccess;
	KTParamRule* pOld;
	KTParamRule* pData;
	int iIndex, iSize = arpData.GetSize();
	for (int i = 0; i < iSize; i++)
	{
		pData = arpData[i];
		ASSERT(NULL != pData);

		if ((iIndex = arItems.GetSize() - 1) >= 0)
		{
			pOld = &(arItems[iIndex]);
			arItems.RemoveAt(iIndex);

			// 构造完整SQL语句
			sAccess.Format(sUpdateSQL, lClassId, pData->GetCurveType(), pData->GetDrawType(),
							pData->GetIndex(), pData->GetFlags(), pOld->GetId());

			// 更新数据
			m_pParamDatabase->ExecuteSQL(sAccess);
			UpdateExpressionData(pOld->GetId(), pData->m_arExpression);
		}
		else
		{
			// 构造完整SQL语句
			sAccess.Format(sInsertSQL, lClassId, pData->GetCurveType(), pData->GetDrawType(),
							pData->GetIndex(), pData->GetFlags());

			// 插入数据
			m_pParamDatabase->ExecuteSQL(sAccess);

			// 构造完整SQL语句
			sAccess.Format(sGetDataSQL, lClassId, pData->GetIndex());

			// 取得插入后的ID
			if (m_pParamDatabase->GetSelData(sAccess, sFlags) > 0)
			{
				pData->SetId(StringToLong(sFlags));
				UpdateExpressionData(pData->GetId(), pData->m_arExpression);
			}
		}

		pData->m_arExpression.RemoveAll();
	}

	// 删除原有多余的属性数据
	iIndex = arItems.GetSize();
	while ((--iIndex) >= 0)
	{
		pOld = &(arItems[iIndex]);

		// 构造完整SQL语句
		sAccess.Format(sDeleteSQL, pOld->GetId());

		// 删除数据
		m_pParamDatabase->ExecuteSQL(sAccess);
		DeleteExpressData(pOld->GetId());
	}

	return TRUE;
}

BOOL KTParamService::UpdateExpressionData(ULONG lRuleId, KTParamExpressionArray& arpData)
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得更新操作SQL语句,检查参数合法性
	CString sUpdateSQL, sFlags;
	GetAccessSQL(_T("UpdateExpressItemById"), sUpdateSQL, sFlags);
	if (sFlags.GetLength() != 6 || sFlags.CompareNoCase(_T("NCCNCN")) != 0)
		return FALSE;

	// 取得插入操作SQL语句,检查参数合法性
	CString sInsertSQL;
	GetAccessSQL(_T("InsertExpressItem"), sInsertSQL, sFlags);
	if (sFlags.GetLength() != 5 || sFlags.CompareNoCase(_T("NCCNC")) != 0)
		return FALSE;

	// 取得删除操作SQL语句,检查参数合法性
	CString sDeleteSQL;
	GetAccessSQL(_T("DeleteExpressItemById"), sDeleteSQL, sFlags);
	if (sFlags.GetLength() != 1 || _T('N') != sFlags[0])
		return FALSE;

	KTParamExpressionArray arItems;
	GetExpressionItems(lRuleId, arItems);

	CString sAccess;
	KTParamExpression* pOld;
	KTParamExpression* pData;
	int iIndex, iSize = arpData.GetSize();
	for (int i = 0; i < iSize; i++)
	{
		pData = &(arpData[i]);
		ASSERT(NULL != pData);

		if ((iIndex = arItems.GetSize() - 1) >= 0)
		{
			pOld = &(arItems[iIndex]);
			arItems.RemoveAt(iIndex);

			// 构造完整SQL语句
			sAccess.Format(sUpdateSQL, lRuleId, pData->GetVarType(), pData->GetValue(),
							pData->GetIndex(), pData->GetFlags(), pOld->GetId());

			// 更新数据
			m_pParamDatabase->ExecuteSQL(sAccess);
		}
		else
		{
			// 构造完整SQL语句
			sAccess.Format(sInsertSQL, lRuleId, pData->GetVarType(), pData->GetValue(),
							pData->GetIndex(), pData->GetFlags());

			// 插入数据
			m_pParamDatabase->ExecuteSQL(sAccess);
		}
	}

	// 删除原有多余的属性数据
	iIndex = arItems.GetSize();
	while ((--iIndex) >= 0)
	{
		pOld = &(arItems[iIndex]);

		// 构造完整SQL语句
		sAccess.Format(sDeleteSQL, pOld->GetId());

		// 删除数据
		m_pParamDatabase->ExecuteSQL(sAccess);
	}

	return TRUE;
}

BOOL KTParamService::DeleteClassData(ULONG lId)
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得操作SQL语句,检查参数合法性
	CString sSQL, sFlags;
	GetAccessSQL(_T("DeleteClassItemById"), sSQL, sFlags);
	if (sFlags.GetLength() != 1 || _T('N') != sFlags[0])
		return FALSE;

	// 构造完整SQL语句
	CString sAccess;
	sAccess.Format(sSQL, lId);

	// 删除数据
	m_pParamDatabase->ExecuteSQL(sAccess);

	return FALSE;
}

BOOL KTParamService::DeleteAttributeData(ULONG lClassId)
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得操作SQL语句,检查参数合法性
	CString sSQL, sFlags;
	GetAccessSQL(_T("DeleteAttrItemByClass"), sSQL, sFlags);
	if (sFlags.GetLength() != 1 || _T('N') != sFlags[0])
		return FALSE;

	// 构造完整SQL语句
	CString sAccess;
	sAccess.Format(sSQL, lClassId);

	// 删除数据
	m_pParamDatabase->ExecuteSQL(sAccess);

	return FALSE;
}

BOOL KTParamService::DeleteRuleData(ULONG lClassId)
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得操作SQL语句,检查参数合法性
	CString sSQL, sFlags;
	GetAccessSQL(_T("DeleteRuleItemByClass"), sSQL, sFlags);
	if (sFlags.GetLength() != 1 || _T('N') != sFlags[0])
		return FALSE;

	// 构造完整SQL语句
	CString sAccess;
	sAccess.Format(sSQL, lClassId);

	// 删除数据
	m_pParamDatabase->ExecuteSQL(sAccess);

	return FALSE;
}

BOOL KTParamService::DeleteExpressData(ULONG lRuleId)
{
	// 确保数据库连接成功
	ASSERT(NULL != m_pParamDatabase);

	// 取得操作SQL语句,检查参数合法性
	CString sSQL, sFlags;
	GetAccessSQL(_T("DeleteExpressByRule"), sSQL, sFlags);
	if (sFlags.GetLength() != 1 || _T('N') != sFlags[0])
		return FALSE;

	// 构造完整SQL语句
	CString sAccess;
	sAccess.Format(sSQL, lRuleId);

	// 删除数据
	m_pParamDatabase->ExecuteSQL(sAccess);

	return FALSE;
}