Middleware_hd/IVR/CellDataComp...

#include "StdAfx.h"
#include "CellDataCompare.h"
#include "IvrFlow.h"
#include "FlowDataProvider.h"


IMPLEMENT_CELL_AUTOCREATE(CCellDataCompare, CELL_NAME_COMPARE)

CCellDataCompare::CCellDataCompare(void)
{
	m_Data1 = "";
	m_Data2 = "";
	m_Data3 = "";
	m_Data1Type = 0;
	m_Data2Type = 0;
	m_Data3Type = 0;
	m_CompareType = 0;
	m_VarType = 0;
	m_TruePos = 0;
	m_FalsePos = 0;
}

CCellDataCompare::CCellDataCompare( CCellDataCompare & cellDataCompare ) : CCellBase(cellDataCompare)
{
	m_Data1 = cellDataCompare.m_Data1;
	m_Data2 = cellDataCompare.m_Data2;
	m_Data3= cellDataCompare.m_Data3;
	m_Data1Type = cellDataCompare.m_Data1Type;
	m_Data2Type = cellDataCompare.m_Data2Type;
	m_Data3Type = cellDataCompare.m_Data3Type;
	m_CompareType = cellDataCompare.m_CompareType;
	m_VarType = cellDataCompare.m_VarType;
	m_TruePos = cellDataCompare.m_TruePos;
	m_FalsePos = cellDataCompare.m_FalsePos;
}


CCellDataCompare::~CCellDataCompare(void)
{
}

/*****************************************************************
**【函数名称】	Operate
**【函数功能】	节点执行函数
**【参数】		
**【返回值】	下一个节点编号
****************************************************************/
int CCellDataCompare::operate( void )
{
	if(m_pIvrFlow == NULL) 
		return CELL_OP_ERROR;

	CString Info;
	_getCellInfo(Info);
	ILogger::getInstance().log(LOG_CLASS_BUSI, LOG_LEVEL_NORMAL, _T("{Cell}: 开始执行[%s]"), Info);

	//运算数1为变量时，查找相应值
	if( m_Data1Type == CELL_DATA_VAR )
	{
		if( !m_pIvrFlow->findVarValue( m_Data1, m_Data1 ) )
		{
			ILogger::getInstance().log(LOG_CLASS_BUSI, LOG_LEVEL_WARNING, _T("{Cell}: 执行[%s]出错, 运算数1[%s]未找到相应值"), Info, m_Data1);
			return m_FalsePos;
		}
	}

	//运算数2为变量时，查找相应值
	if( m_Data2Type == CELL_DATA_VAR )
	{
		if( !m_pIvrFlow->findVarValue( m_Data2, m_Data2 ) )
		{
			ILogger::getInstance().log(LOG_CLASS_BUSI, LOG_LEVEL_WARNING, _T("{Cell}: 执行[%s]出错, 运算数2[%s]未找到相应值"), Info, m_Data2);
			return m_FalsePos;
		}
	}

	//比价区间时且运算数3为变量时，查找相应值
	if( m_Data3Type == CELL_DATA_VAR && m_CompareType == DATA_COMPARE_IN )
	{
		if( !m_pIvrFlow->findVarValue( m_Data3, m_Data3 ) )
		{
			ILogger::getInstance().log(LOG_CLASS_BUSI, LOG_LEVEL_WARNING, _T("{Cell}: 执行[%s]出错, 运算数3[%s]未找到相应值"), Info, m_Data3);
			return m_FalsePos;
		}
	}

	bool CompareResult = false;

	switch(m_CompareType)
	{
	case DATA_COMPARE_E:
		{
			if(m_VarType == VAR_TYPE_INT)
			{
				int IntCompare1 = atoi( m_Data1 );
				int IntCompare2 = atoi( m_Data2 );
				if(IntCompare1 == IntCompare2)
					CompareResult = TRUE;
			}
			else
			{
				if( m_Data1 == m_Data2 )
					CompareResult = TRUE;
			}
		}
		break;

	case DATA_COMPARE_G:
		{
			if(m_VarType == VAR_TYPE_INT)
			{
				int IntCompare1 = atoi( m_Data1 );
				int IntCompare2 = atoi( m_Data2 );
				if( IntCompare1 > IntCompare2 )
					CompareResult = TRUE;
			}
			else
			{
				if( m_Data1 > m_Data2 )
					CompareResult = TRUE;
			}
		}
		break;

	case DATA_COMPARE_GE:
		{
			if(m_VarType == VAR_TYPE_INT)
			{
				int IntCompare1 = atoi( m_Data1 );
				int IntCompare2 = atoi( m_Data2 );
				if( IntCompare1 >= IntCompare2 )
					CompareResult = TRUE;
			}
			else
			{
				if( m_Data1 >= m_Data2 )
					CompareResult = TRUE;
			}
		}
		break;

	case DATA_COMPARE_L:
		{
			if(m_VarType == VAR_TYPE_INT)
			{
				int IntCompare1 = atoi( m_Data1 );
				int IntCompare2 = atoi( m_Data2 );
				if( IntCompare1 < IntCompare2 )
					CompareResult = TRUE;
			}
			else
			{
				if( m_Data1 < m_Data2 )
					CompareResult = TRUE;
			}
		}
		break;

	case DATA_COMPARE_LE:
		{
			if(m_VarType == VAR_TYPE_INT)
			{
				int IntCompare1 = atoi( m_Data1 );
				int IntCompare2 = atoi( m_Data2 );
				if( IntCompare1 <= IntCompare2 )
					CompareResult = TRUE;
			}
			else
			{
				if( m_Data1 <= m_Data2 )
					CompareResult = TRUE;
			}
		}
		break;

	case DATA_COMPARE_IN:
		{
			if(m_VarType == VAR_TYPE_INT)
			{
				int IntCompare1 = atoi( m_Data1 );
				int IntCompare2 = atoi( m_Data2 );
				int IntCompare3 = atoi( m_Data3 );
				if( (IntCompare1 > IntCompare2) && (IntCompare1 < IntCompare3) )
					CompareResult = TRUE;
			}
			else
			{
				if( (m_Data1 > m_Data2) && (m_Data1 < m_Data3))
					CompareResult = TRUE;
			}
		}
		break;

	default:
		ASSERT(FALSE);
		break;
	}		

	if (CompareResult)
	{
		ILogger::getInstance().log(LOG_CLASS_BUSI, LOG_LEVEL_NORMAL, _T("{Cell}: 执行[%s]结束, 比较结果为真"), Info);
		return m_TruePos;
	}
	else
	{
		ILogger::getInstance().log(LOG_CLASS_BUSI, LOG_LEVEL_NORMAL, _T("{Cell}: 执行[%s]结束, 比较结果为假"), Info);
		return m_FalsePos;
	}
}

/*****************************************************************
**【函数名称】	copy
**【函数功能】	拷贝自身
**【参数】		
**【返回值】	拷贝副本
****************************************************************/
CCellBase * CCellDataCompare::copy( void )
{
	CCellBase * pCellBase = new CCellDataCompare(*this);
	return pCellBase;
}

/*****************************************************************
**【函数名称】	fillData
**【函数功能】	节点解析,填充数据
**【参数】		Provider：数据提供器
**【返回值】	成功true，失败false
****************************************************************/
bool CCellDataCompare::fillData( IFlowDataProvider& Provider )
{
	CString Data;

	do 
	{
		if(!Provider.getData(CELL_ATTRIBUTE_POS, Data))
		{
			Data = _T("节点号");
			break;
		}
		else
		{
			sscanf_s(Data, _T("%d"), &m_Pos);
			if(m_Pos < 1)
			{
				Data = _T("节点号");
				break;
			}
		}

		if(!Provider.getData(CELL_ATTRIBUTE_DATA1_TYPE, Data))
		{
			Data = _T("操作数1类型");
			break;
		}
		else
		{
			sscanf_s(Data, _T("%d"), &m_Data1Type);
			if(m_Data1Type != CELL_DATA_VAL && m_Data1Type != CELL_DATA_VAR)
			{
				Data = _T("操作数1类型");
				break;
			}
		}
	
		if(!Provider.getData(CELL_ATTRIBUTE_DATA2_TYPE, Data))
		{
			Data = _T("操作数2类型");
			break;
		}
		else
		{
			sscanf_s(Data, _T("%d"), &m_Data2Type);
			if(m_Data2Type != CELL_DATA_VAL && m_Data2Type != CELL_DATA_VAR)
			{
				Data = _T("操作数2类型");
				break;
			}
		}

		if(!Provider.getData(CELL_ATTRIBUTE_DATA3_TYPE, Data))
		{
			Data = _T("操作数3类型");
			break;
		}
		else
		{
			sscanf_s(Data, _T("%d"), &m_Data3Type);
			if(m_Data3Type != CELL_DATA_VAL && m_Data3Type != CELL_DATA_VAR)
			{
				Data = _T("操作数3类型");
				break;
			}
		}

		if(!Provider.getData(CELL_ATTRIBUTE_DATA1, m_Data1))
		{
			Data = _T("操作数1");
			break;
		}

		if(!Provider.getData(CELL_ATTRIBUTE_DATA2, m_Data2))
		{
			Data = _T("操作数2");
			break;
		}

		if(!Provider.getData(CELL_ATTRIBUTE_DATA3, m_Data3))
		{
			Data = _T("操作数3");
			break;
		}

		if(!Provider.getData(CELL_ATTRIBUTE_VAR_TYPE, Data))
		{
			Data = _T("变量类型");
			break;
		}
		else
		{
			sscanf_s(Data, _T("%d"), &m_VarType);
			if(m_VarType != VAR_TYPE_INT && m_VarType != VAR_TYPE_STRING)
			{
				Data = _T("变量类型");
				break;
			}
		}

		if(!Provider.getData(CELL_ATTRIBUTE_COMPARE_TYPE, Data))
		{
			Data = _T("比较类型");
			break;
		}
		else
		{
			sscanf_s(Data, _T("%d"), &m_CompareType);
			if(m_CompareType < DATA_COMPARE_E && m_CompareType > DATA_COMPARE_IN)
			{
				Data = _T("比较类型");
				break;
			}
		}

		if(!Provider.getData(CELL_ATTRIBUTE_TRUE_POS, Data))
		{
			Data = _T("比较为真跳转节点");
			break;
		}
		else
		{
			sscanf_s(Data, _T("%d"), &m_TruePos);
			if(m_TruePos < 0)
			{
				Data = _T("比较为真跳转节点");
				break;
			}
		}

		if(!Provider.getData(CELL_ATTRIBUTE_FALSE_POS, Data))
		{
			Data = _T("比较为假跳转节点");
			break;
		}
		else
		{
			sscanf_s(Data, _T("%d"), &m_FalsePos);
			if(m_FalsePos < 0)
			{
				Data = _T("比较为假跳转节点");
				break;
			}
		}

		Provider.getData(CELL_ATTRIBUTE_NOTE, m_Note);

		return true;

	} while (false);

	ILogger::getInstance().log(LOG_CLASS_BUSI, LOG_LEVEL_ERROR, _T("{Cell}: 节点[%s]解析失败, '%s'错误"), CELL_NAME_COMPARE, Data);

	return false;
}