midware_ws/NetLib/FsLink/OperationRea...

#include "StdAfx.h"
#include "OperationReactor.h"
#include "DevControl.h"
#include "ChanExten.h"
#include "ChanTrunk.h"
#include "FsProxy.h"
#include "OpAnswer.h"
#include "OpHangup.h"
#include "OpConsult.h"
#include "OpInsert.h"
#include "OpInstead.h"
#include "OpIntercept.h"
#include "OpLeaveWord.h"
#include "OpListen.h"
#include "OpMakeCall.h"
#include "OpTransfer.h"
#include "OpTurnExten.h"
#include "OpTrunk2Trunk.h"
#include "OpTurnIvr.h"
#include "OpMeeting.h"
#include "OpHoldon.h"
#include "OpMute.h"
#include "OpPlayAndDtmf.h"
#include "OpRecord.h"
#include "OpPredictionCall.h"
#include "OpSetChannelVar.h"
#include "OpSendDtmf.h"

SINGLETON_IMPLEMENT(COperationReactor)

COperationReactor::COperationReactor(void)
{
}

COperationReactor::~COperationReactor(void)
{
}

/*****************************************************************
**【函数名称】	__addOperation
**【函数功能】	存储一个操作
**【参数】		
**【返回值】	
*****************************************************************/
void COperationReactor::__addOperation( COperation* pOperation )
{
	m_TaskLock.Lock();
	m_TableOperation.SetAt(pOperation->uniqueId(), pOperation);
	m_TaskLock.Unlock();

}

/*****************************************************************
**【函数名称】	__delOperation
**【函数功能】	删除指定操作
**【参数】		
**【返回值】	
*****************************************************************/
bool COperationReactor::__delOperation( COperation* pOperation )
{
	m_TaskLock.Lock();
	bool b= m_TableOperation.RemoveKey(pOperation->uniqueId()) == TRUE;
	m_TaskLock.Unlock();
	return b;
}

/*****************************************************************
**【函数名称】	__getOperation
**【函数功能】	获取指定操作
**【参数】		
**【返回值】	
*****************************************************************/
COperation* COperationReactor::__getOperation( LONG OpId )
{

	m_TaskLock.Lock();
	COperation* pOp = NULL;
	m_TableOperation.Lookup(OpId, pOp);
	m_TaskLock.Unlock();
	return pOp;
}

/*****************************************************************
**【函数名称】	__execOp
**【函数功能】	执行OP
**【参数】		pOp			操作实体
				pParam		操作参数
**【返回值】		
****************************************************************/
bool COperationReactor::__execOp( COperation* pOp, LineOpParam* pParam )
{
	__addOperation(pOp);

	if(pOp->start(pParam))
		return true;
	
	if(__delOperation(pOp))
	{
		pOp->detachHostChan();
		FS_LINK_DELETE(pOp);
	}
	return false;
}

/*****************************************************************
**【函数名称】	__procOpMakeCall
**【函数功能】	坐席外呼处理
**【参数】		
**【返回值】		
****************************************************************/
bool COperationReactor::__procOpMakeCall( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	// 通过设备资源查找主控线路
	CChanExten* pExten = CFsProxy::GetInstance().getExten(ResID);
	if(pExten == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行分机呼叫失败, 未找到分机通道[%lu], DestNum = %s"), ResID, pParam->szParam2);
		return false;
	}

	// 生成外呼操作类
	COperation* pOp = new(std::nothrow) COpMakeCall(this, Instance);
	if (pOp == NULL) {
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行分机呼叫失败,内存不足"));
		return false;
	}
	if(!pOp->attachHostChan(pExten))
	{
		// 如果线路正在执行其它操作
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行分机呼叫失败, 无法绑定通道[%lu], ChanCurTask = %d, DestNum = %s"), ResID, 
			(pExten->currOp() == NULL ? LINE_OP_UNKNOWN : pExten->currOp()->type()), pParam->szParam2);
		
		FS_LINK_DELETE(pOp);
		return false;
	}

	// 启动操作
	return __execOp(pOp, pParam);
}

/*****************************************************************
**【函数名称】	__procPredictionCall
**【函数功能】	预测外呼
**【参数】		
**【返回值】		
****************************************************************/
bool COperationReactor::__procOpPCall( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	// 生成自动呼叫操作类
	COperation* pOp = new(std::nothrow) COpPredictionCall(this, Instance);
	if (pOp == NULL) {
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行预测外呼,内存不足"));
		return false;
	}
	// 启动操作
	return __execOp(pOp, pParam);
}

/*****************************************************************
**【函数名称】	__procOpAnswerCall
**【函数功能】	应答呼叫
**【参数】		
**【返回值】		
****************************************************************/
bool COperationReactor::__procOpAnswerCall( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	// 查找要应答呼叫的线路
	CChanExten* pExten = CFsProxy::GetInstance().getExten(ResID);
	if(pExten == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行分机应答失败, 未找到分机通道[%lu]"), ResID);
		return false;
	}

	// 生成应答呼叫操作类
	COperation* pOp = new(std::nothrow) COpAnswer(this, Instance);
	if (pOp == NULL) {
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行应答,内存不足"));
		return false;
	}
	if(!pOp->attachHostChan(pExten))
	{
		// 如果线路正在执行其它操作
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行分机应答失败, 无法绑定通道[%lu], ChanCurTask = %d"), ResID, 
			(pExten->currOp() == NULL ? LINE_OP_UNKNOWN : pExten->currOp()->type()));
		FS_LINK_DELETE(pOp);
		return false;
	}
	
	// 启动操作
	return __execOp(pOp, pParam);
}

/*****************************************************************
**【函数名称】	__procOpHangUp
**【函数功能】	挂机操作处理
**【参数】
**【返回值】
****************************************************************/
bool COperationReactor::__procOpHangUp( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	// 查找要挂机的线路
	CVirtualChan* pChan = CFsProxy::GetInstance().getExten(ResID);
	if(pChan == NULL)
		pChan = CFsProxy::GetInstance().getTrunk(ResID);
	if(pChan == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行挂机操作失败, 未找到通道[%lu]"), ResID);
		return false;
	} // end if



	// 如果线路正在执行其它操作
	if (pChan->currOp() != NULL)
	{
		if (pChan->currOp()->type() == LINE_OP_HANG_UP)
		{
			LOGGER(LOG_LEVEL_NORMAL, _T("{OperationReactor}: 当前线路正在执行挂机"));
			return false; // 使任务删除
		}
		LOGGER(LOG_LEVEL_NORMAL, _T("{OperationReactor}: 执行挂机, 当前线路绑定操作, Operation = %d"), pChan->currOp()->type());
		return pChan->currOp()->hangup(Instance);
	}
		
	if (pChan->state() == CHAN_LOGIC_STATE_FREE || pChan->state() == CHAN_LOGIC_STATE_DISABLED)
	{
		LOGGER(LOG_LEVEL_NORMAL, _T("{OperationReactor}: 当前线路已挂机"));
		return false; // 使任务删除
	}

	// 执行挂机操作
	COperation* pOp = new(std::nothrow) COpHangup(this, Instance);
	if (pOp == NULL) {
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行挂机操作,内存不足"));
		return false;
	}
	if(!pOp->attachHostChan(pChan))
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行挂机操作失败, 无法绑定通道[%lu], ChanCurTask = %d"), ResID, 
			(pChan->currOp() == NULL ? LINE_OP_UNKNOWN : pChan->currOp()->type()));
		FS_LINK_DELETE(pOp);
		return false;
	}

	// 启动操作
	return __execOp(pOp, pParam);
}

/*****************************************************************
**【函数名称】	__procOpTransfer
**【函数功能】	座席呼叫转移
**【参数】
**【返回值】
****************************************************************/
bool COperationReactor::__procOpTransfer( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	// 通过设备资源查找主控线路
	CChanExten* pExten = CFsProxy::GetInstance().getExten(ResID);
	if(pExten == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行呼叫转移失败, 未找到分机通道[%lu], DestNum = %s"), ResID, pParam->szParam2);
		return false;
	}

	COperation* pOp = new(std::nothrow) COpTransfer(this, Instance);
	if (pOp == NULL) {
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行转移,内存不足"));
		return false;
	}
	if(!pOp->attachHostChan(pExten))
	{
		// 如果通道正在执行其它操作
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行呼叫转移失败, 无法绑定通道[%lu], ChanCurTask = %d, DestNum = %s"), ResID, 
			(pExten->currOp() == NULL ? LINE_OP_UNKNOWN : pExten->currOp()->type()), pParam->szParam2);
		FS_LINK_DELETE(pOp);
		return false;
	}

	// 启动操作
	return __execOp(pOp, pParam);
}

/*****************************************************************
**【函数名称】	__procOpTurnAgent
**【函数功能】	外线转座席
**【参数】		
**【返回值】		
****************************************************************/
bool COperationReactor::__procOpTurnAgent( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	// 通过设备资源查找主控线路
	CVirtualChan* pChan = CFsProxy::GetInstance().getTrunk(ResID);
	if(pChan == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行中继转座席失败, 未找到中继通道[%lu], ExtenNum = %s"), ResID, pParam->szParam2);
		return false;
	}

	// 生成外线呼叫转移操作类
	COperation* pOp = new(std::nothrow) COpTurnExten(this, Instance);
	if (pOp == NULL) {
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行外线呼叫转移,内存不足"));
		return false;
	}
	if(!pOp->attachHostChan(pChan))
	{
		// 当前线路是否正在进行其它操作
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行中继转座席失败, 无法绑定通道[%lu], ChanCurTask = %d, ExtenNum = %s"), ResID, 
			(pChan->currOp() == NULL ? LINE_OP_UNKNOWN : pChan->currOp()->type()), pParam->szParam2);
		FS_LINK_DELETE(pOp);
		return false;
	}

	// 启动操作
	return __execOp(pOp, pParam);
}

/*****************************************************************
**【函数名称】	__procOpTurnOut
**【函数功能】	外线呼叫跳转
**【参数】		
**【返回值】		
****************************************************************/
bool COperationReactor::__procOpTurnOut( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	// 通过设备资源查找主控线路
	CVirtualChan* pChan = CFsProxy::GetInstance().getTrunk(ResID);
	if(pChan == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行中继呼叫跳转失败, 未找到中继通道[%lu], DestNum = %s"), ResID, pParam->szParam2);
		return false;
	}

	// 生成外线呼叫转移操作类
	COperation* pOp = new(std::nothrow) COpTrunk2Trunk(this, Instance);
	if (pOp == NULL) {
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行外线呼叫转移,内存不足"));
		return false;
	}
	if(!pOp->attachHostChan(pChan))
	{
		// 当前线路是否正在进行其它操作
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行中继呼叫跳转失败, 无法绑定通道[%lu], ChanCurTask = %d, DestNum = %s"), ResID, 
			(pChan->currOp() == NULL ? LINE_OP_UNKNOWN : pChan->currOp()->type()), pParam->szParam2);
		FS_LINK_DELETE(pOp);
		return false;
	}
	
	// 启动操作
	return __execOp(pOp, pParam);
}

/*****************************************************************
**【函数名称】	__procOpTurnIvr
**【函数功能】	转IVR
**【参数】		
**【返回值】	
****************************************************************/
bool COperationReactor::__procOpTurnIvr( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	// 查找要转IVR的线路
	CChanExten* pExten = CFsProxy::GetInstance().getExten(ResID);
	if(pExten == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行跳转IVR操作失败, 未找到分机通道[%lu]"), ResID);
		return false;
	} // end if

	// 执行转IVR操作
	COperation* pOp = new(std::nothrow) COpTurnIvr(this, Instance);
	if (pOp == NULL) {
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行转IVR,内存不足"));
		return false;
	}
	if(!pOp->attachHostChan(pExten))
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行跳转IVR操作失败, 无法绑定通道[%lu], ChanCurTask = %d"), ResID, 
			(pExten->currOp() == NULL ? LINE_OP_UNKNOWN : pExten->currOp()->type()));
		FS_LINK_DELETE(pOp);
		return false;
	} // end if

	return __execOp(pOp, pParam);
}

/*****************************************************************
**【函数名称】	__procReqMeeting
**【函数功能】	单步会议
**【参数】		
**【返回值】	
****************************************************************/
bool COperationReactor::__procOpMeeting( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	// 通过设备资源查找主控线路
	CChanExten* pExten = CFsProxy::GetInstance().getExten(ResID);
	if(pExten == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行会议操作失败, 未找到分机通道[%lu], DestNum = %s"), ResID, pParam->szParam2);
		return false;
	}

	COperation* pOp = new(std::nothrow) COpMeeting(this, Instance);
	if (pOp == NULL) {
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行会议,内存不足"));
		return false;
	}
	if(!pOp->attachHostChan(pExten))
	{
		// 如果线路正在执行其它操作
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行会议操作失败, 无法绑定通道[%lu], ChanCurTask = %d, DestNum = %s"), ResID, 
			(pExten->currOp() == NULL ? LINE_OP_UNKNOWN : pExten->currOp()->type()), pParam->szParam2);
		FS_LINK_DELETE(pOp);
		return false;
	}

	// 启动操作
	return __execOp(pOp, pParam);
}

bool COperationReactor::__procOpMeetingTackBack(LONG Instance, ULONG ResID, LineOpParam * pParam)
{
	// 通过设备资源查找主控线路
	CChanExten* pExten = CFsProxy::GetInstance().getExten(ResID);
	if (pExten == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行会议接回操作失败, 未找到分机通道[%lu]"), ResID);
		return false;
	}

	// 如果线路正在执行其它操作
	COperation* pCurrOp = pExten->currOp();
	if (pCurrOp == NULL || pCurrOp->type() != LINE_OP_CONFERENCE)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行会议接回操作失败, 分机通道[%lu]当前未在会议"), ResID);
		return false;
	}

	// 执行会议接回主叫操作
	return pCurrOp->cancel(Instance);
}

/*****************************************************************
**【函数名称】	__procOpHold
**【函数功能】	座席通话保持操作处理
**【参数】		Instance		调用标识
				ResID			操作的主控资源ID
				LineOpParam*	操作信息
**【返回值】	启动操作是否成功
****************************************************************/
bool COperationReactor::__procOpHold( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	// 通过设备资源查找主控线路
	CChanExten* pExten = CFsProxy::GetInstance().getExten(ResID);
	if(pExten == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行保持操作失败, 未找到分机通道[%lu]"), ResID);
		return false;
	}

	// 生成保持操作类
	COperation* pOp = new(std::nothrow) COpHoldon(this, Instance);
	if (pOp == NULL) {
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行保持,内存不足"));
		return false;
	}
	if(!pOp->attachHostChan(pExten))
	{
		// 如果线路正在执行其它操作
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行保持操作失败, 无法绑定通道[%lu], ChanCurTask = %d"), ResID, 
			(pExten->currOp() == NULL ? LINE_OP_UNKNOWN : pExten->currOp()->type()));
		FS_LINK_DELETE(pOp);
		return false;
	}

	// 启动操作
	return __execOp(pOp, pParam);
}

/*****************************************************************
**【函数名称】	__procOpTakeBack
**【函数功能】	座席通话接回操作处理
**【参数】		Instance		调用标识
				ResID			操作的主控资源ID
				LineOpParam*	操作信息
**【返回值】	启动操作是否成功
****************************************************************/
bool COperationReactor::__procOpTakeBack( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	// 通过设备资源查找主控线路
	CChanExten* pExten = CFsProxy::GetInstance().getExten(ResID);
	if(pExten == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行保持接回操作失败, 未找到分机通道[%lu]"), ResID);
		return false;
	}

	// 如果线路正在执行其它操作
	COperation* pCurrOp = pExten->currOp();
	if(pCurrOp == NULL || pCurrOp->type() != LINE_OP_HOLD)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行保持接回操作失败, 分机通道[%lu]当前未保持"), ResID);
		return false;
	}
	
	// 执行取消静音操作
	return pCurrOp->cancel(Instance);
}

/*****************************************************************
**【函数名称】	__procOpMuteOn
**【函数功能】	静音启动
**【参数】		
**【返回值】	
****************************************************************/
bool COperationReactor::__procOpMuteOn( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	// 通过设备资源查找主控线路
	CChanExten* pExten = CFsProxy::GetInstance().getExten(ResID);
	if(pExten == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行静音操作失败, 未找到分机通道[%lu]"), ResID);
		return false;
	}

	// 生成静音操作类
	COperation* pOp = new(std::nothrow) COpMute(this, Instance);
	if (pOp == NULL) {
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行静音,内存不足"));
		return false;
	}
	if(!pOp->attachHostChan(pExten))
	{
		// 如果线路正在执行其它操作
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行静音操作失败, 无法绑定通道[%lu], ChanCurTask = %d"), ResID, 
			(pExten->currOp() == NULL ? LINE_OP_UNKNOWN : pExten->currOp()->type()));
		FS_LINK_DELETE(pOp);
		return false;
	}

	// 启动操作
	return __execOp(pOp, pParam);
}

/*****************************************************************
**【函数名称】	__procOpMuteOff
**【函数功能】	静音取消
**【参数】		
**【返回值】	
****************************************************************/
bool COperationReactor::__procOpMuteOff( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	// 通过设备资源查找主控线路
	CChanExten* pExten = CFsProxy::GetInstance().getExten(ResID);
	if(pExten == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行取消静音操作失败, 未找到分机通道[%lu]"), ResID);
		return false;
	}

	// 如果线路正在执行其它操作
	COperation* pCurrOp = pExten->currOp();
	if(pCurrOp == NULL || pCurrOp->type() != LINE_OP_MUTE_BEGIN)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行取消静音操作失败, 分机通道[%lu]当前未静音"), ResID);
		return false;
	}

	// 执行取消静音操作
	return pCurrOp->cancel(Instance);
}

/*****************************************************************
**【函数名称】	__procOpReset
**【函数功能】	重置
**【参数】	
**【返回值】	
****************************************************************/
bool COperationReactor::__procOpReset( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	// 通过设备资源查找主控线路
	CChanExten* pExten = CFsProxy::GetInstance().getExten(ResID);
	if(pExten == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行通道重置操作失败, 未找到分机通道[%lu]"), ResID);
		return false;
	}

	LOGGER(LOG_LEVEL_NORMAL, _T("{OperationReactor}: 执行通道重置操作, ChanNo = %lu"), ResID);

	// 清除关联操作
	COperation* pOp = pExten->currOp();
	if(pOp != NULL)
	{
		pOp->hangup(FS_LINK_INSTANCE_INVALID);
		if(__delOperation(pOp))
		{
			pOp->detachHostChan();
			FS_LINK_DELETE(pOp);
		}
	}
	else
	{
		if(!pExten->isFree())
			CFsProxy::GetInstance().kill(FS_LINK_JOBID_INVALID, pExten);
	} // end if

	return true;
}

/*****************************************************************
**【函数名称】	__procOpListen
**【函数功能】	监听
**【参数】		
**【返回值】	
****************************************************************/
bool COperationReactor::__procOpListen( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	// 通过设备资源查找主控线路
	CChanExten* pExten = CFsProxy::GetInstance().getExten(ResID);
	if(pExten == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行监听操作失败, 未找到分机通道[%lu], DestNum = %s"), 
			ResID, pParam->szParam2);
		return false;
	}

	// 生成强插操作类
	COperation* pOp = new(std::nothrow) COpListen(this, Instance);
	if (pOp == NULL) {
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行监听,内存不足"));
		return false;
	}
	if(!pOp->attachHostChan(pExten))
	{
		// 如果线路正在执行其它操作
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行监听操作失败, 无法绑定通道[%lu], ChanCurTask = %d, DestNum = %s"), 
			ResID, (pExten->currOp() == NULL ? LINE_OP_UNKNOWN : pExten->currOp()->type()), pParam->szParam2);
		FS_LINK_DELETE(pOp);
		return false;
	}

	// 启动操作
	return __execOp(pOp, pParam);
}

/*****************************************************************
**【函数名称】	__procOpInsert
**【函数功能】	强插
**【参数】		
**【返回值】	
****************************************************************/
bool COperationReactor::__procOpInsert( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	// 通过设备资源查找主控线路
	CChanExten* pExten = CFsProxy::GetInstance().getExten(ResID);
	if(pExten == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行强插操作失败, 未找到分机通道[%lu], DestNum = %s"), ResID, pParam->szParam2);
		return false;
	}

	// 生成强插操作类
	COperation* pOp = new(std::nothrow) COpInsert(this, Instance);
	if (pOp == NULL) {
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行强插,内存不足"));
		return false;
	}
	if(!pOp->attachHostChan(pExten))
	{
		// 如果线路正在执行其它操作
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行强插操作失败, 无法绑定通道[%lu], ChanCurTask = %d, DestNum = %s"), 
			ResID, (pExten->currOp() == NULL ? LINE_OP_UNKNOWN : pExten->currOp()->type()), pParam->szParam2);
		FS_LINK_DELETE(pOp);
		return false;
	}

	// 启动操作
	return __execOp(pOp, pParam);
}

/*****************************************************************
**【函数名称】	__procReqInstead
**【函数功能】	代接
**【参数】		
**【返回值】	
****************************************************************/
bool COperationReactor::__procOpInstead( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	// 通过设备资源查找主控线路
	CChanExten* pExten = CFsProxy::GetInstance().getExten(ResID);
	if(pExten == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行代接操作失败, 未找到分机通道[%lu], DestNum = %s"), ResID, pParam->szParam2);
		return false;
	}

	// 生成代接操作类
	COperation* pOp = new(std::nothrow) COpInstead(this, Instance);
	if (pOp == NULL) {
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行代接,内存不足"));
		return false;
	}
	if(!pOp->attachHostChan(pExten))
	{
		// 如果线路正在执行其它操作
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行代接操作失败, 无法绑定通道[%lu], ChanCurTask = %d, DestNum = %s"), 
			ResID, (pExten->currOp() == NULL ? LINE_OP_UNKNOWN : pExten->currOp()->type()), pParam->szParam2);
		FS_LINK_DELETE(pOp);
		return false;
	}

	// 启动操作
	return __execOp(pOp, pParam);
}

/*****************************************************************
**【函数名称】	__procReqIntercept
**【函数功能】	强截
**【参数】	
**【返回值】	
****************************************************************/
bool COperationReactor::__procOpIntercept( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	// 通过设备资源查找主控线路
	CChanExten* pExten = CFsProxy::GetInstance().getExten(ResID);
	if(pExten == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行强截操作失败, 未找到分机通道[%lu], DestNum = %s"), ResID, pParam->szParam2);
		return false;
	}

	// 生成强截操作类
	COperation* pOp = new(std::nothrow) COpIntercept(this, Instance);
	if (pOp == NULL) {
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行强截,内存不足"));
		return false;
	}
	if(!pOp->attachHostChan(pExten))
	{
		// 如果线路正在执行其它操作
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行强截操作失败, 无法绑定通道[%lu], ChanCurTask = %d, DestNum = %s"), 
			ResID, (pExten->currOp() == NULL ? LINE_OP_UNKNOWN : pExten->currOp()->type()), pParam->szParam2);
		FS_LINK_DELETE(pOp);
		return false;
	}

	// 启动操作
	return __execOp(pOp, pParam);
}

/*****************************************************************
**【函数名称】	__procOpInfoTransaction
**【函数功能】	数据交互
**【参数】		
**【返回值】	启动操作是否成功
****************************************************************/
bool COperationReactor::__procOpInfoTransaction( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	// 通过设备资源查找主控线路
	CChanExten* pExten = CFsProxy::GetInstance().getExten(ResID);
	if(pExten == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行数据交换操作失败, 未找到分机通道[%lu]"), ResID);
		return false;
	}

	// 查找线路关联的操作
	COperation* pCurrOp = pExten->currOp();
	if(pCurrOp == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行数据交换操作失败, 分机通道[%lu]未绑定任务"), ResID);
		return false;
	}		

	// 执行信息交互
	pCurrOp->setOpInstance(Instance);
	return true;
}

/*****************************************************************
**【函数名称】	__procOpConsultBegin
**【函数功能】	协商呼叫启动
**【参数】		
**【返回值】	
****************************************************************/
bool COperationReactor::__procOpConsultBegin( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	// 通过设备资源查找主控线路
	CChanExten* pExten = CFsProxy::GetInstance().getExten(ResID);
	if(pExten == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行协商呼叫操作失败, 未找到分机通道[%lu], DestNum = %s"), ResID, pParam->szParam2);
		return false;
	}

	// 生成协商呼叫操作类
	COperation* pOp = new(std::nothrow) COpConsult(this, Instance);
	if (pOp == NULL) {
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行协商呼叫,内存不足"));
		return false;
	}
	if(!pOp->attachHostChan(pExten))
	{
		// 如果线路正在执行其它操作
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行协商呼叫操作失败, 无法绑定通道[%lu], ChanCurTask = %d, DestNum = %s"), 
			ResID, (pExten->currOp() == NULL ? LINE_OP_UNKNOWN : pExten->currOp()->type()), pParam->szParam2);
		FS_LINK_DELETE(pOp);
		return false;
	}

	// 启动操作
	return __execOp(pOp, pParam);
}

/*****************************************************************
**【函数名称】	__procOpConsultConfirm
**【函数功能】	协商呼叫确认
**【参数】		
**【返回值】
****************************************************************/
bool COperationReactor::__procOpConsultConfirm( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	// 通过设备资源查找主控线路
	CChanExten* pExten = CFsProxy::GetInstance().getExten(ResID);
	if(pExten == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行协商确认操作失败, 未找到分机通道[%lu]"), ResID);
		return false;
	}

	// 如果线路未执行协商呼叫操作
	COperation* pCurrOp = pExten->currOp();
	if(pCurrOp == NULL || pCurrOp->type() != LINE_OP_CONSULT_CALL_BEGIN)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行协商确认操作失败, 分机通道[%lu]未在协商呼叫环境中"), ResID);
		return false;
	}


	if (pParam->nParam1==3)
	{
		// 执行操作确认
		if(!pCurrOp->cancel(Instance))
		{
			if(__delOperation(pCurrOp))
			{
				pCurrOp->detachHostChan();
				FS_LINK_DELETE(pCurrOp);
			}
			return false;
		} // end if
	}
	else
	{

		// 执行操作确认
		if(!pCurrOp->next(Instance))
		{
			if(__delOperation(pCurrOp))
			{
				pCurrOp->detachHostChan();
				FS_LINK_DELETE(pCurrOp);
			}
			return false;
		} // end if

	}
	return true;
}

/*****************************************************************
**【函数名称】	__procOpPlayAndDtmf
**【函数功能】	线路放音收号
**【参数】		
**【返回值】		
****************************************************************/
bool COperationReactor::__procOpPlayAndDtmf( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	// 通过设备资源查找主控线路
	CVirtualChan* pChan = CFsProxy::GetInstance().getTrunk(ResID);
	if(pChan == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行放音收号操作失败, 未找到通道[%lu], mode = %d, AudioFile = %s"), 
			ResID, pParam->nParam1, pParam->szParam3);
		return false;
	}

	COperation* pCurrOp = pChan->currOp();

	if(pParam->nParam1 == PVM_STOP_PLAY)	// 停止放音
	{
		// 如果线路未在执行放音操作
		if(pCurrOp == NULL || pCurrOp->type() != LINE_OP_PLAY_VOICE)
		{
			LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行停止放音操作失败, 通道[%lu]未执行放音操作"), ResID);
			return false;
		}
		else
			return pCurrOp->cancel(Instance);	// 执行取消操作
	}
	else							// 启动放音
	{
		// 生成放音操作类
		COperation* pOp = new(std::nothrow) COpPlayAndDtmf(this, Instance);
		if (pOp == NULL) {
			LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行放音,内存不足"));
			return false;
		}
		if(!pOp->attachHostChan(pChan))
		{
			// 如果线路正在执行其它操作
			LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行放音收号操作失败, 无法绑定通道[%lu], ChanCurTask = %d, AudioFile = %s"), 
				ResID, (pChan->currOp() == NULL ? LINE_OP_UNKNOWN : pChan->currOp()->type()), pParam->szParam3);
			FS_LINK_DELETE(pOp);
			return false;
		}

		// 启动操作
		return __execOp(pOp, pParam);
	}
}

/*****************************************************************
**【函数名称】	__procOpRecord
**【函数功能】	线路录音
**【参数】		
**【返回值】	
****************************************************************/
bool COperationReactor::__procOpRecord( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	// 查找要录音的线路
	CVirtualChan* pChan = CFsProxy::GetInstance().getTrunk(ResID);
	if(pChan == NULL)
		pChan = CFsProxy::GetInstance().getExten(ResID);
	if(pChan == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行录音操作失败, 未找到通道[%lu]"), ResID);
		return false;
	} // end if

	// 生成录音操作类
	COperation* pOp = new(std::nothrow) COpRecord(this, Instance);
	if (pOp == NULL) {
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行录音,内存不足"));
		return false;
	}
	if(!pOp->attachHostChan(pChan))
	{
		// 如果线路正在执行其它操作
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行录音操作失败, 无法绑定通道[%lu], ChanCurTask = %d"), ResID, 
			(pChan->currOp() == NULL ? LINE_OP_UNKNOWN : pChan->currOp()->type()));
		FS_LINK_DELETE(pOp);
		return false;
	}

	// 启动操作
	return __execOp(pOp, pParam);
}

/*****************************************************************
**【函数名称】	__procOpLeaveWord
**【函数功能】	留言录音
**【参数】		
**【返回值】	
****************************************************************/
bool COperationReactor::__procOpLeaveWord( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	// 查找要留言的线路
	CVirtualChan* pChan = CFsProxy::GetInstance().getTrunk(ResID);			// 外线
	if(pChan == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行留言操作失败, 未找到通道[%lu]"), ResID);
		return false;
	} // end if

	// 生成留言操作类
	COperation* pOp = new(std::nothrow) COpLeaveWord(this, Instance);
	if (pOp == NULL) {
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行留言,内存不足"));
		return false;
	}
	if(!pOp->attachHostChan(pChan))
	{
		// 如果线路正在执行其它操作
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行留言操作失败, 无法绑定通道[%lu], ChanCurTask = %d"), ResID, 
			(pChan->currOp() == NULL ? LINE_OP_UNKNOWN : pChan->currOp()->type()));
		FS_LINK_DELETE(pOp);
		return false;
	}

	// 启动操作
	return __execOp(pOp, pParam);
}

/*****************************************************************
**【函数名称】	__procOpFax
**【函数功能】	传真
**【参数】		
**【返回值】	
****************************************************************/
bool COperationReactor::__procOpFax( LONG Instance, ULONG ResID, LineOpParam* pParam )
{
	return false;
}

/*****************************************************************
**【函数名称】	__procOpSetChannelVar
**【函数功能】	设置通道变量
**【参数】
**【返回值】
****************************************************************/
bool COperationReactor::__procOpSetChannelVar(LONG Instance, ULONG ResID, LineOpParam * pParam)
{
	// 查找要设置通道变量的线路
	CVirtualChan* pChan = CFsProxy::GetInstance().getTrunk(ResID);
	if (pChan == NULL)
		pChan = CFsProxy::GetInstance().getExten(ResID);
	if (pChan == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行设置通道变量操作失败, 未找到通道[%lu]"), ResID);
		return false;
	} // end if

	// 生成设置通道变量操作类
	COperation* pOp = new(std::nothrow) COpSetChannelVar(this, Instance);
	if (pOp == NULL) {
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行设置通道变量,内存不足"));
		return false;
	}
	if (pOp == NULL) {
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行放音,内存不足"));
		return false;
	}
	if (!pOp->attachHostChan(pChan))
	{
		// 如果线路正在执行其它操作
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行设置通道变量操作失败, 无法绑定通道[%lu], ChanCurTask = %d"), ResID,
			(pChan->currOp() == NULL ? LINE_OP_UNKNOWN : pChan->currOp()->type()));
		FS_LINK_DELETE(pOp);
		return false;
	}

	// 启动操作
	return __execOp(pOp, pParam);
}

bool COperationReactor::__procOpSendDtmf(LONG Instance, ULONG ResID, LineOpParam * pParam)
{
	// 查找要设置通道变量的线路
	CVirtualChan* pChan = CFsProxy::GetInstance().getTrunk(ResID);
	if (pChan == NULL)
		pChan = CFsProxy::GetInstance().getExten(ResID);
	if (pChan == NULL)
	{
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行发送按键操作失败, 未找到通道[%lu]"), ResID);
		return false;
	} // end if

	// 生成设置通道变量操作类
	COperation* pOp = new(std::nothrow) COpSendDtmf(this, Instance);
	if (pOp == NULL) {
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行发送按键,内存不足"));
		return false;
	}
	if (!pOp->attachHostChan(pChan))
	{
		// 如果线路正在执行其它操作
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行发送按键操作失败, 无法绑定通道[%lu], ChanCurTask = %d"), ResID,
			(pChan->currOp() == NULL ? LINE_OP_UNKNOWN : pChan->currOp()->type()));
		FS_LINK_DELETE(pOp);
		return false;
	}

	// 启动操作
	return __execOp(pOp, pParam);
}

/*****************************************************************
**【函数名称】	procOperation
**【函数功能】	线路操作处理
**【参数】		
**【返回值】		
****************************************************************/
bool COperationReactor::procOperation( LONG Instance, UINT OpType, ULONG ResID, LineOpParam* pParam )
{
	LOGGER(LOG_LEVEL_NORMAL, _T("{OperationReactor}: 通道操作, OpType = %lu,通道[%lu]"), OpType, ResID);

	bool Res = false;

	// 根据操作类型进行分类处理
	switch(OpType)
	{
	case LINE_OP_MAKE_CALL:				// 座席外呼
		Res = __procOpMakeCall(Instance, ResID, pParam);
		break;

	case LINE_OP_ANSWER_CALL:			// 应答呼叫
		Res = __procOpAnswerCall(Instance, ResID, pParam);
		break;

	case LINE_OP_PREDICTION_CALL:		// 预测外呼
		Res = __procOpPCall(Instance, ResID, pParam);
		break;

	case LINE_OP_HANG_UP:				// 挂机
		Res = __procOpHangUp(Instance, ResID, pParam);
		break;

	case LINE_OP_TRANSFER:				// 呼叫转移
		Res = __procOpTransfer(Instance, ResID, pParam);
		break;

	case LINE_OP_TURNAGENT:				// 转坐席
		Res = __procOpTurnAgent(Instance, ResID, pParam);
		break;

	case LINE_OP_TURNOUT:				// 转外线
		Res = __procOpTurnOut(Instance, ResID, pParam);
		break;

	case LINE_OP_TURNIVR:				// 转IVR
		Res = __procOpTurnIvr(Instance, ResID, pParam);
		break;

	case LINE_OP_CONFERENCE:			// 单步会议
		Res = __procOpMeeting(Instance, ResID, pParam);
		break;
	case LINE_OP_CONFERENCE_TAKEBACK:   // 会议接回主叫
		Res = __procOpMeetingTackBack(Instance, ResID, pParam);
		break;
	case LINE_OP_LISTEN:				// 监听
		Res = __procOpListen(Instance, ResID, pParam);
		break;

	case LINE_OP_INSERT:				// 强插
		Res = __procOpInsert(Instance, ResID, pParam);
		break;

	case LINE_OP_RESET:					// 重置
		Res = __procOpReset(Instance, ResID, pParam);
		break;

	case LINE_OP_INSTEAD:				// 代接
		Res = __procOpInstead(Instance, ResID, pParam);
		break;

	case LINE_OP_GRAB:					// 强截
		Res = __procOpIntercept(Instance, ResID, pParam);
		break;

	case LINE_OP_TRANSFER_INFO:			// 信息交互
		Res = __procOpInfoTransaction(Instance, ResID, pParam);
		break;

	case LINE_OP_PLAY_VOICE:			// 放音收号
		Res = __procOpPlayAndDtmf(Instance, ResID, pParam);
		break;

	case LINE_OP_FAX:					// 传真
		Res = __procOpFax(Instance, ResID, pParam);
		break;

	case LINE_OP_RECORD:				// 录音
		Res = __procOpRecord(Instance, ResID, pParam);
		break;

	case LINE_OP_LEAVEWORD:				// 留言
		Res = __procOpLeaveWord(Instance, ResID, pParam);
		break;

	case LINE_OP_MUTE_BEGIN:			// 静音开始
		Res = __procOpMuteOn(Instance, ResID, pParam);		
		break;

	case LINE_OP_MUTE_END:				// 静音结束
		Res = __procOpMuteOff(Instance, ResID, pParam);	
		break;

	case LINE_OP_HOLD:					// 保持
		Res = __procOpHold(Instance, ResID, pParam);
		break;

	case LINE_OP_TAKEBACK:				// 接回
		Res = __procOpTakeBack(Instance, ResID, pParam);
		break;

	case LINE_OP_CONSULT_CALL_BEGIN:	// 协商呼叫启动
		Res = __procOpConsultBegin(Instance, ResID, pParam);
		break;

	case LINE_OP_CONSULT_CALL_CONFIRM:	// 协商呼叫确认
		Res = __procOpConsultConfirm(Instance, ResID, pParam);
		break;

	case LINE_OP_IVRFAX_TRANSFER:		
		{
			CDevControl::GetInstance().onEventOpResult(Instance, true, NULL);
			Res = true;
		}
		break;
	case LINE_OP_SET_CHANNEL_VARIABLE:  // 设置通道变量
		Res = __procOpSetChannelVar(Instance, ResID, pParam);
		break;
	case LINE_OP_SEND_DTMF:            // 发送按键
		Res = __procOpSendDtmf(Instance, ResID, pParam);
			break;
	default:
		ASSERT(FALSE);
	} // end switch

	return Res;
}

/*****************************************************************
**【函数名称】	onOpProcess
**【函数功能】	操作进展返回
**【参数】		Instance		调用标识
				HostLine		主控线路ID
				AssoLine		关联线路ID
				AssoLineType	关联线路类型
				CallerNum		主叫号码
				CalleeNum		被叫号码
**【返回值】		
****************************************************************/
void COperationReactor::onOpProcess( LONG Instance, UINT HostChanNo, UINT AssoChanNo, DEV_RES_TYPE AssoChanType, LPCTSTR CallerNum, LPCTSTR CalleeNum )
{
	CDevControl::GetInstance().onEventOpProcess(Instance, HostChanNo, AssoChanNo, AssoChanType, CallerNum, CalleeNum);
}

/*****************************************************************
**【函数名称】	onOpResult
**【函数功能】	操作结果返回
**【参数】		Instance		调用标识
				IsSucceed		操作结果
				pInfo			附加信息
**【返回值】		
****************************************************************/
void COperationReactor::onOpResult( LONG Instance, bool IsSucceed )
{
	CDevControl::GetInstance().onEventOpResult(Instance, IsSucceed, NULL);
}

/*****************************************************************
**【函数名称】	onOpResult
**【函数功能】	操作结果返回
**【参数】		Instance		调用标识
				pOp				返回操作结果的操作实体指针
				IsSucceed		操作结果
				pInfo			附加信息
**【返回值】		
****************************************************************/
void COperationReactor::onOpResult( LONG Instance, COperation* pOp, bool IsSucceed, CString Data /*= _T("")*/ )
{
	ASSERT(pOp != NULL);

	if (pOp == NULL)return;
	if (__delOperation(pOp))		// 非取消操作的返回结果
	{
		// 关闭线路关联
		pOp->detachHostChan();

		// 释放操作
		FS_LINK_DELETE(pOp);
	} // end if

	// 返回执行结果
	CDevControl::GetInstance().onEventOpResult(Instance, IsSucceed, Data);
}
//2019.3.7
void COperationReactor::releaseOpResult( COperation* pOp)
{
	if (pOp == NULL)return;

	pOp->clean();

	if (__delOperation(pOp))		// 非取消操作的返回结果
	{
		// 关闭线路关联
		pOp->detachHostChan();

		// 释放操作
		FS_LINK_DELETE(pOp);
	} // end if

}
/*****************************************************************
**【函数名称】	onOpFromDev
**【函数功能】	设备主动操作事件
**【参数】		pChan			主动操作的通道
				OpType			操作类型
				CallerNum		主叫号码
				CalleeNum		被叫号码
**【返回值】
****************************************************************/
void COperationReactor::onOpFromDev( CVirtualChan* pChan, DEV_OP OpType, LPCTSTR CallerNum, LPCTSTR CalleeNum )
{
	CDevControl::GetInstance().onEventDevOperation(pChan->no(), OpType, CallerNum, CalleeNum);
}

/*****************************************************************
**【函数名称】	onExtenCallFromDev
**【函数功能】	分机直接外呼
**【参数】		
**【返回值】	
*****************************************************************/
bool COperationReactor::onExtenCallFromDev( CVirtualChan* pHostChan, PCHAN_EVENT_NOTIFY pNotify )
{
	COpMakeCall* pMakeCall = new(std::nothrow) COpMakeCall(this, FS_LINK_INSTANCE_INVALID);
	if (pMakeCall == NULL) {
		LOGGER(LOG_LEVEL_WARNING, _T("{OperationReactor}: 执行分机直呼,内存不足"));
		return false;
	}
	pMakeCall->attachHostChan(pHostChan);
	if(pMakeCall->start(pNotify))
	{
		__addOperation(pMakeCall);
		return true;

	}
	else
	{
		pMakeCall->detachHostChan();
		FS_LINK_DELETE(pMakeCall);
		return false;
	}
}

/*****************************************************************
**【函数名称】	onEslEvtBgJobDone
**【函数功能】	后台任务执行结束事件处理
**【参数】		
**【返回值】	
*****************************************************************/
void COperationReactor::onEslEvtBgJobDone( PBG_JOB_NOTIFY pNotify )
{
	ASSERT(pNotify != NULL);
	COperation* pOperation = __getOperation(pNotify->JobInstance);
	if(pOperation != NULL)
		pOperation->onBackgroudJobDone(pNotify);
}

/*****************************************************************
**【函数名称】	onEslEvtChanState
**【函数功能】	通道状态事件处理
**【参数】		
**【返回值】	
*****************************************************************/
void COperationReactor::onEslEvtChanState( LONG OpInstance, CVirtualChan* pChan )
{
	COperation* pOperation = __getOperation(OpInstance);
	if(pOperation != NULL)
		pOperation->onAssoChanStateUpdated(pChan);
}