MiddleWares_YiHe/IVR/CellCalculat...

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


IMPLEMENT_CELL_AUTOCREATE(CCellCalculate, CELL_NAME_CALCULATE)

CCellCalculate::CCellCalculate(void)
{
	m_ResultVarName = "";
	m_Count1 = "";
	m_Count2 = "";
	m_Count1DataType = 0;
	m_Count2DataType = 0;
	m_CountType = 0;
	m_ResultType = 0;
	m_NextPos = 0;
}

CCellCalculate::CCellCalculate( CCellCalculate & cellCalculate ) : CCellBase(cellCalculate)
{
	m_ResultVarName = cellCalculate.m_ResultVarName;
	m_Count1 = cellCalculate.m_Count1;
	m_Count2 = cellCalculate.m_Count2;
	m_Count1DataType = cellCalculate.m_Count1DataType;
	m_Count2DataType = cellCalculate.m_Count2DataType;
	m_CountType = cellCalculate.m_CountType;
	m_ResultType = cellCalculate.m_ResultType;
	m_NextPos = cellCalculate.m_NextPos;
}


CCellCalculate::~CCellCalculate(void)
{
}

/*****************************************************************
**【函数名称】	Operate
**【函数功能】	节点执行函数
**【参数】		
**【返回值】	下一个节点编号
****************************************************************/
int CCellCalculate::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);

	if( m_Count1DataType == CELL_DATA_VAR )
	{
		if( !m_pIvrFlow->findVarValue( m_Count1, m_Count1 ) )
		{
			ILogger::getInstance().log(LOG_CLASS_BUSI, LOG_LEVEL_WARNING, _T("{Cell}: 执行[%s]出错, 运算数1[%s]未找到相应值"), Info, m_Count1);
			return CELL_OP_ERROR;
		}
	}

	if( m_Count2DataType == CELL_DATA_VAR )
	{
		if( !m_pIvrFlow->findVarValue( m_Count2, m_Count2 ) )
		{
			ILogger::getInstance().log(LOG_CLASS_BUSI, LOG_LEVEL_WARNING, _T("{Cell}: 执行[%s]出错, 运算数2[%s]未找到相应值"), Info, m_Count2);
			return CELL_OP_ERROR;
		}
	}

	CString strResultValue = "";
	if( m_ResultType == VAR_TYPE_INT )
	{
		int nCount1 = 0;
		int nCount2 = 0;
		int nResult = 0;
		nCount1 = atoi( m_Count1 );		
		nCount2 = atoi( m_Count2 );		

		//运算类型，加1、减2、乘3、除4
		if( m_CountType == CALCU_TYPE_ADD )
			nResult = nCount1 + nCount2;
		else if( m_CountType== CALCU_TYPE_SUB )
			nResult = nCount1 - nCount2;
		else if( m_CountType== CALCU_TYPE_MULT )
			nResult = nCount1 * nCount2;
		else
		{
			if( nCount2 == 0 )
			{
				ILogger::getInstance().log(LOG_CLASS_BUSI, LOG_LEVEL_WARNING, _T("{Cell}: 执行[%s]出错, 除运算中除数为零"), Info);
				return CELL_OP_ERROR;
			}

			nResult = nCount1 / nCount2;
		}
		strResultValue.Format( "%d", nResult );
	}
	else
	{
		double fCount1, fCount2, fResult;
		fCount1 = atof( m_Count1 );		
		fCount2 = atof( m_Count1 );

		//运算类型，加1、减2、乘3、除4
		if( m_CountType == CALCU_TYPE_ADD )
			fResult = fCount1 + fCount2;
		else if( m_CountType== CALCU_TYPE_SUB )
			fResult = fCount1 - fCount2;
		else if( m_CountType== CALCU_TYPE_MULT )
			fResult = fCount1 * fCount2;
		else
		{
			if( fCount2 == 0 )
			{
				ILogger::getInstance().log(LOG_CLASS_BUSI, LOG_LEVEL_WARNING, _T("{Cell}: 执行[%s]出错, 除运算中除数为零"), Info);
				return CELL_OP_ERROR;
			}
			fResult = fCount1 / fCount2;
		}
		strResultValue.Format("%f", fResult);
	}
	ILogger::getInstance().log(LOG_CLASS_BUSI, LOG_LEVEL_NORMAL, _T("{Cell}: 执行[%s]结束, 结果[%s : %s]"), Info, m_ResultVarName, strResultValue);
	m_pIvrFlow->addVar(m_ResultVarName, strResultValue);

	return m_NextPos;
}

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

/*****************************************************************
**【函数名称】	fillData
**【函数功能】	节点解析,填充数据
**【参数】		Provider：数据提供器
**【返回值】	成功true，失败false
****************************************************************/
bool CCellCalculate::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_Count1DataType);
			if(m_Count1DataType != CELL_DATA_VAR && m_Count1DataType != CELL_DATA_VAL)
			{
				Data = _T("操作数1类型");
				break;
			}
		}

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

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

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

		if(!Provider.getData(CELL_ATTRIBUTE_CALCU_TYPE, Data))
		{
			Data = _T("运算类型");
			break;
		}
		else
		{
			sscanf_s(Data, _T("%d"), &m_CountType);
			if(m_CountType < CALCU_TYPE_ADD || m_CountType > CALCU_TYPE_DIV)
			{
				Data = _T("运算类型");
				break;
			}
		}

		if(!Provider.getData(CELL_ATTRIBUTE_RESULT_TYPE, Data))
		{
			Data = _T("结果类型");
			break;
		}
		else
		{
			sscanf_s(Data, _T("%d"), &m_ResultType);
			if(m_ResultType != VAR_TYPE_INT && m_ResultType != VAR_TYPE_FLOAT)
			{
				Data = _T("结果类型");
				break;
			}
		}

		if(!Provider.getData(CELL_ATTRIBUTE_RESULT_VAR, m_ResultVarName))
		{
			Data = _T("结果变量");
			break;
		}

		if(!Provider.getData(CELL_ATTRIBUTE_NEXT, Data))
		{
			Data = _T("下一节点号");
			break;
		}
		else
		{
			sscanf_s(Data, _T("%d"), &m_NextPos);
			if(m_NextPos < 1)
			{
				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_CALCULATE, Data);

	return false;
}