middleware_xinyang-asr/ACD/Agent.cpp

#include "StdAfx.h"
#include "Agent.h"
#include "Config.h"
#include "SLogic.h"
#include "AcdCore.h"
#include "MsgCenter.h"
#include "NetworkAcd.h"
#include "Exten.h"
#include "YamlConfig.h"

CAgent::CAgent(UINT a_AgentID, UINT a_ExtID, LPCTSTR a_GroupID, UINT a_AgentType, UINT a_PostProcessingTime)
{
	// 网络属性
	CNetworkAcd::GetInstance().getAgentLinkInfo(a_AgentID, m_AgentIp, m_AgentPort);

	// 基本属性
	m_AgentID = a_AgentID;
	m_Exten = a_ExtID;
	m_GroupID = a_GroupID;
	m_AgentType = (AGENT_TYPE)a_AgentType;
	m_State = AGENT_STATE_UNKNOWN;
	m_AssoExtState = INNER_STATE_FREE;
	m_IsRepose = false;

	m_bFirstQueue = true;

	// 业务属性
	m_AnswerCount = 0;
	m_ReposeCount = 0;
	m_TimeFree = 0;
	m_TimeRepos = 0;
	m_TimeTalk = 0;
	m_TypePostProcessing = CConfig::postProcessingType(); //2020-03-02 话后处理类型
	m_TimePostProcessing = (a_PostProcessingTime == 0) ? CConfig::postProcessingTime() : a_PostProcessingTime;

	/*******************2019-12-19**********************/
	m_AnswerCountOld = 0;
	m_ReposeCountOld = 0;
	m_TimeFreeOld = 0;
	m_TimeReposOld = 0;
	m_TimeTalkOld = 0;
	CString curDay;
	CTime tm;
	tm = CTime::GetCurrentTime();
	curDay = tm.Format("%Y-%m-%d ");
	CString startTime, endTime;
	startTime = "00:00";
	endTime = "23:59";
	startTime = curDay + startTime;
	endTime = curDay + endTime;
	YamlConfig* fig = YamlConfig::GetInstance();
	if (fig->GetIsUsed())
	{
		map<string, string> m_Times = fig->GetTimeMap();
		if (m_Times.size() > 0)
		{
			map<string, string>::iterator it = m_Times.begin();
			while (it != m_Times.end())
			{
				CTime ts = YamlConfig::timestr((curDay.GetString() + it->first).c_str());  // 开始时间
				CTime te = YamlConfig::timestr((curDay.GetString() + it->second).c_str());  //  结束时间
				if (ts > te)  // 如果开始时间大于结束时间，则结束时间为第二天的时间
					te = te + CTimeSpan(1, 0, 0, 0);
				if (tm > ts && tm < te)   // 当前时间在该时间段内则使用该考核时间段
				{
					startTime = ts.Format("%Y-%m-%d %H:%M");
					endTime = te.Format("%Y-%m-%d %H:%M");
					cout << startTime << "**" << endTime << endl;
					break;
				}
				cout << startTime << "遍历" << endTime << endl;
				++it;
			}
		}
		CString sql;
		sql.Format("SELECT sum([FreeTimes])[FreeTimes],sum([ReposeTimes])[ReposeTimes] ,sum([TalkTimes])[TalkTimes] ,sum([ReposeNum])[ReposeNum],sum([AnswerNum])[AnswerNum] "
			"FROM [dbo].[rep_agent_detail] where  AgentId = %d and TimeLogin  between '%s' and '%s'", a_AgentID, startTime, endTime);
		ILogger::getInstance().log(LOG_CLASS_BUSI, LOG_LEVEL_NORMAL, "初始化座席信息sql：%s", sql);
		IOtlConnection* pConn = IOtlConnection::getInstance();
		IOtlRecordset* record = pConn->QueryRecords(sql);
		if (record != NULL)
		{
			if (!record->IsEOF())
			{
				record->MoveNextRow();
				m_AnswerCountOld = record->GetValueInt("AnswerNum");
				m_ReposeCountOld = record->GetValueInt("ReposeNum");
				m_TimeFreeOld = record->GetValueInt("FreeTimes");
				m_TimeReposOld = record->GetValueInt("ReposeTimes");
				m_TimeTalkOld = record->GetValueInt("TalkTimes");
				ILogger::getInstance().log(LOG_CLASS_BUSI, LOG_LEVEL_NORMAL, "初始化座席业务信息:AnswerNum = %d,ReposeNum = %d,FreeTimes = %d,ReposeTimes = %d,TalkTimes = %d", m_AnswerCountOld, m_ReposeCountOld, m_TimeFreeOld, m_TimeReposOld, m_TimeTalkOld);
			}
		}
		IOtlRecordset::DestroyInstance(record);		// 释放记录集
	}

	/*************************************************/

	// 定时器初始化
	m_PollTimer.SetTimedEvent(this, &CAgent::__onTimerPoll);
	m_PollTimer.Start(1000);
	// 通知统计模块座席签入
	__reportLogin();

	// 添加消息可供视图刷新
	CMsgCenter::GetInstance().pushMsg(ACD_MSG_AGENT_STATE_UPDAET, (const PARAM)m_AgentID);
}

//CAgent::CAgent(UINT a_AgentID, UINT a_ExtID, LPCTSTR a_GroupID, UINT a_AgentType, const CAgentProperty& AgentProperty)
//{
//	// 网络属性
//	CNetworkAcd::GetInstance().getAgentLinkInfo(a_AgentID, m_AgentIp, m_AgentPort);
//
//	// 基本属性
//	m_AgentID = a_AgentID;
//	m_Exten = a_ExtID;
//	m_GroupID = a_GroupID;
//	m_AgentType = (AGENT_TYPE)a_AgentType;
//	m_State = AGENT_STATE_UNKNOWN;
//	m_AssoExtState = INNER_STATE_FREE;
//	m_IsRepose = false;
//
//	// 业务属性
//	m_AnswerCount = AgentProperty.m_AnswerCount;
//	m_ReposeCount = AgentProperty.m_ReposeCount;
//	m_TimeFree = AgentProperty.m_TimeFree;
//	m_TimeRepos = AgentProperty.m_TimeRepos;
//	m_TimeTalk = AgentProperty.m_TimeTalk;
//	m_TimePostProcessing = (AgentProperty.m_TimePostProcessing == 0) ? CConfig::postProcessingTime() : AgentProperty.m_TimePostProcessing;
//
//	// 定时器初始化
//	m_PollTimer.SetTimedEvent(this, &CAgent::__onTimerPoll);
//	m_PollTimer.Start(1000);
//	// 通知统计模块座席签入
//	__reportLogin();
//
//	// 添加消息可供视图刷新
//	CMsgCenter::GetInstance().pushMsg(ACD_MSG_AGENT_STATE_UPDAET, (const PARAM)m_AgentID);
//}

CAgent::~CAgent(void)
{
	m_PollTimer.StopSafely();
	m_AgentTimer.StopSafely();
}


/*****************************************************************
**【函数名称】	__reportLogin
**【函数功能】	签出统计通知
**【参数】
**【返回值】
****************************************************************/
void CAgent::__reportLogin()
{
	// 通知统计模块 REP_EVENT_LOGIN
	T_EvtLogIn repLogin = { 0 };
	repLogin.nAgentID = m_AgentID;
	repLogin.nExtID = m_Exten;
	repLogin.nAgentType = m_AgentType;
	lstrcpy(repLogin.szGroup, m_GroupID);
	lstrcpy(repLogin.szAgentIP, m_AgentIp);

	CSLogic::GetInstance().onSEvent(m_AgentID, m_Exten, REP_EVENT_LOGIN, &repLogin, m_GroupID);  // 2021-11-10 签入时传递组号;
}

/*****************************************************************
**【函数名称】	__reportLogout
**【函数功能】	签出统计通知
**【参数】		HostAgent: 签出当前座席的主控座席
**【返回值】
****************************************************************/
void CAgent::__reportLogout(const UINT HostAgent)
{
	if (m_State == AGENT_STATE_REPOSE)
		__onStatusUpdate(AGENT_STATE_REPOSE, false);

	if (m_State == AGENT_STATE_POST_PROCESSING)
		__onStatusUpdate(AGENT_STATE_POST_PROCESSING, false);

	if (m_State == AGENT_STATE_FREE)
		__onStatusUpdate(AGENT_STATE_FREE, false);

	// 通知统计模块 REP_EVENT_LOGOUT
	T_EvtLogout repLogout = { 0 };
	repLogout.nLogoutHost = HostAgent;
	repLogout.nTimeFree = m_TimeFree;
	repLogout.nTimeRepose = m_TimeRepos;
	repLogout.nTimeTalk = m_TimeTalk;
	repLogout.nAnswerCount = m_AnswerCount;
	repLogout.nReposeCount = m_ReposeCount;

	CSLogic::GetInstance().onSEvent(m_AgentID, m_Exten, REP_EVENT_LOGOUT, &repLogout);
}

/*****************************************************************
**【函数名称】	__onStatusUpdate
**【函数功能】	座席状态变更通知
**【参数】
**【返回值】
****************************************************************/
void CAgent::__onStatusUpdate(AGENT_STATE State, bool StartFlag)
{
	T_EvtStatus EvtStatus;

	EvtStatus.State = State;
	EvtStatus.StartFlag = StartFlag;

	CSLogic::GetInstance().onSEvent(m_AgentID, m_Exten, REP_EVENT_STATE, &EvtStatus);
}

/*****************************************************************
**【函数名称】	__reportStatus
**【函数功能】	通知各方座席当前状态
**【参数】
**【返回值】
****************************************************************/
void CAgent::__reportStatus(void)
{
	// 通知OCX座席当前状态
	CPduEntity Cmd(PDU_CMD_ACD_AGENT_STATE);
	Cmd.SetDataUInt(0, m_Exten);
	Cmd.SetDataUInt(1, m_AgentID);
	Cmd.SetDataUInt(2, m_State);
	//CNetworkAcd::GetInstance().send2Agent(m_AgentID, &Cmd);
	CNetworkAcd::GetInstance().send2Server(&Cmd);

	// 添加消息可供视图刷新
	CMsgCenter::GetInstance().pushMsg(ACD_MSG_AGENT_STATE_UPDAET, (PARAM)m_AgentID);
}

/*****************************************************************
**【函数名称】	__reportStatus
**【函数功能】	通知各方座席当前状态
**【参数】
**【返回值】
ych 2018.5.17
****************************************************************
void CAgent::__reportStatus(void)
{
	CExten* pExten = CAcdCore::GetInstance().getExtenCtrl().getExten(m_Exten); // 获取指定分机
	if (pExten == NULL)
	{
		// 显示日志 ych 2018.5.17
		ILogger::getInstance().log(LOG_CLASS_BUSI, LOG_LEVEL_ERROR, _T("{CAgent::__reportStatus}: pExten指针为NULL"));
		return;
	}
	if (m_AgentID !=0 && m_AgentID == pExten->assoAgent())
	{
		CPduEntity Cmd(PDU_CMD_CTI_LINE_STATE);
		Cmd.SetDataUInt(0, pExten->GetID());
		Cmd.SetDataUInt(1, pExten->GetState());
		Cmd.SetDataULong(2, pExten->GetCallId());
		Cmd.SetDataUInt(3, pExten->GetAssoAgent());
		Cmd.SetDataString(4, pExten->GetCallerNum());
		Cmd.SetDataString(5, pExten->GetCalleeNum());
		Cmd.SetDataString(6, pExten->GetDataBind());
		Cmd.SetDataUInt(7, pExten->GetPeerLineType());
		Cmd.SetDataUInt(8, pExten->GetInfoEx());
		Cmd.SetDataUInt(9, pExten->GetFinalExt());
		Cmd.SetDataUInt(10, pExten->GetOpType());
		Cmd.SetDataUInt(11, 0);
		Cmd.SetDataUInt(12, m_State);
		//CNetworkAcd::GetInstance().send2Agent(m_AssoAgent, &Cmd);
		CNetworkAcd::GetInstance().send2Server(&Cmd);

		// 显示日志 ych 2018.5.17
		ILogger::getInstance().log(LOG_CLASS_BUSI, LOG_LEVEL_NORMAL, _T("{CAgent::__reportStatus}: 返回线路及座席状态"));

		// 添加消息可供视图刷新
		CMsgCenter::GetInstance().pushMsg(ACD_MSG_AGENT_STATE_UPDAET, (PARAM)m_AgentID);
	}
}*/
/*****************************************************************
**【函数名称】	__onTimerPoll
**【函数功能】	轮询定时器处理
**【参数】
**【返回值】
****************************************************************/
void CAgent::__onTimerPoll(void)
{
	if (m_State == AGENT_STATE_FREE)
		m_TimeFree++;
	else if (m_State == AGENT_STATE_BUSY)
		m_TimeTalk++;

	if (m_IsRepose)
		m_TimeRepos++;
}

/*****************************************************************
**【函数名称】	__onTimerPostProcessing
**【函数功能】	话后处理时长定时器处理
**【参数】
**【返回值】
****************************************************************/
void CAgent::__onTimerPostProcessing(void)
{
	if (m_State == AGENT_STATE_POST_PROCESSING)
	{
		//setState(AGENT_STATE_FREE);
		setFreeForAgentCall(); // 2020-04-03 根据安图修改 座席置忙外呼后座席设置置忙
	}
}

/*****************************************************************
**【函数名称】	__onTimerLock
**【函数功能】	座席被锁定超时处理
**【参数】
**【返回值】
****************************************************************/
void CAgent::__onTimerLock(void)
{
	if (m_State == AGENT_STATE_REQUESTED)
	{
		//setState(AGENT_STATE_FREE, true);
		setFreeForAgentCall(true); // 2020-04-03 根据安图修改 座席置忙外呼后座席设置置忙
	}
}

/*****************************************************************
**【函数名称】	__setTimer
**【函数功能】	设立定时器
**【参数】
**【返回值
****************************************************************/
void CAgent::__setTimer(UINT TimmerId, UINT Elapse)
{
	if (TimmerId == TIMER_POST_PROCESSING)
	{
		m_AgentTimer.StopSafely();
		m_AgentTimer.SetTimedEvent(this, &CAgent::__onTimerPostProcessing);
		m_AgentTimer.Start(Elapse, false, true, WT_EXECUTEDEFAULT);
	}
	else if (TimmerId == TIMER_LOCK_PERIOD)
	{
		m_AgentTimer.StopSafely();
		m_AgentTimer.SetTimedEvent(this, &CAgent::__onTimerLock);
		m_AgentTimer.Start(Elapse, false, true, WT_EXECUTEDEFAULT);
	}
	else
	{
		ASSERT(FALSE);
	}
}

/*****************************************************************
**【函数名称】	__killTimer
**【函数功能】	删除定时器
**【参数】
**【返回值
****************************************************************/
void CAgent::__killTimer(UINT TimmerId)
{
	m_AgentTimer.Stop();
}

/*****************************************************************
**【函数名称】	release
**【函数功能】	清理资源
**【参数】		HostAgent: 主控制坐席工号
**【返回值】
****************************************************************/
void CAgent::release(UINT HostAgent)
{
	m_PollTimer.StopSafely();
	m_AgentTimer.StopSafely();

	// 设置状态为注销
	setState(AGENT_STATE_LOGOUT);

	// 通知统计模块 REP_EVENT_LOGOUT
	__reportLogout(HostAgent);

	// 关闭Agent端SOCKET连接
	CNetworkAcd::GetInstance().shutDownAgentLink(m_AgentID);

	// 添加消息可供视图刷新
	CMsgCenter::GetInstance().pushMsg(ACD_MSG_AGENT_LOGOUT, (const PARAM)m_AgentID);
}

/*****************************************************************
**【函数名称】	setState
**【函数功能】	设置座席状态
**【参数】		a_AgentState：座席当前逻辑状态
**【返回值】
****************************************************************/
BOOL CAgent::setState(AGENT_STATE a_AgentState, bool IsForce/* = false*/)
{
	CSingleLock Locker(&m_Cs4Lock, TRUE);

	switch (a_AgentState)
	{
	case AGENT_STATE_BUSY:			// 通话
	{
		switch (m_State)
		{
		case AGENT_STATE_BUSY:
			__reportStatus();  // 2020-04-03 根据安图修改 座席置忙外呼后座席设置置忙
			return TRUE;
			break;
		case AGENT_STATE_REQUESTED:
			__killTimer(TIMER_LOCK_PERIOD);
			break;
		case AGENT_STATE_POST_PROCESSING:
		{
			__killTimer(TIMER_POST_PROCESSING);
			__onStatusUpdate(AGENT_STATE_POST_PROCESSING, false);
		}
		break;
		case AGENT_STATE_REPOSE:
		{
			m_IsRepose = false;
			__onStatusUpdate(AGENT_STATE_REPOSE, false);
		}
		break;
		case AGENT_STATE_LOGOUT:
			return FALSE;
			break;
		}

		__onStatusUpdate(AGENT_STATE_BUSY, true);
		m_State = AGENT_STATE_BUSY;
	}
	break;

	case AGENT_STATE_REPOSE:		// 小休
	{
		switch (m_State)
		{
		case AGENT_STATE_REPOSE:
			m_IsRepose = true;   // 2020-04-03 根据安图修改 座席置忙外呼后座席设置置忙
			__reportStatus();    // 2020-04-03 根据安图修改 座席置忙外呼后座席设置置忙
			return TRUE;
			break;
		case AGENT_STATE_POST_PROCESSING:
		{
			__killTimer(TIMER_POST_PROCESSING);
			__onStatusUpdate(AGENT_STATE_POST_PROCESSING, false);
		}
		break;
		case AGENT_STATE_BUSY:
		case AGENT_STATE_LOGOUT:
		case AGENT_STATE_REQUESTED:
			return FALSE;
			break;
		case AGENT_STATE_FREE:   // 2021-11-22 保存坐席空闲状态结束
			__onStatusUpdate(AGENT_STATE_FREE, false);
			break;
		}

		m_ReposeCount++;
		m_IsRepose = true;
		m_State = AGENT_STATE_REPOSE;
		// 统计小休开始
		__onStatusUpdate(AGENT_STATE_REPOSE, true);
	}
	break;

	case AGENT_STATE_POST_PROCESSING:	// 话后处理
	{
		// 电话挂断后重新计算空闲时长   2020-03-05
		YamlConfig* fig = YamlConfig::GetInstance();
		if (!fig->GetIsUsed()&&fig->GetIsResetFreeTime())
		{
			m_TimeFree = 0;
		}
		//

		switch (m_State)
		{
		case AGENT_STATE_POST_PROCESSING:
			__reportStatus();   // 2020-04-03 根据安图修改 座席置忙外呼后座席设置置忙
			return TRUE;
			break;
		case AGENT_STATE_BUSY:
			__onStatusUpdate(AGENT_STATE_BUSY, false);
			break;
		case AGENT_STATE_FREE:
		case AGENT_STATE_REPOSE:
		case AGENT_STATE_REQUESTED:
		case AGENT_STATE_LOGOUT:
			return FALSE;
			break;
		}

		// 统计话后处理开始
		__onStatusUpdate(AGENT_STATE_POST_PROCESSING, true);
		m_State = AGENT_STATE_POST_PROCESSING;

		//if (m_TimePostProcessing > 0)
		//	__setTimer(TIMER_POST_PROCESSING, m_TimePostProcessing * 1000);		// 启动话后处理定时器

		if (m_TimePostProcessing > 0 && m_TypePostProcessing==0)  // 2020-03-02
			__setTimer(TIMER_POST_PROCESSING, m_TimePostProcessing * 1000);		// 启动话后处理定时器
	}
	break;

	case AGENT_STATE_FREE:			// 空闲
	{
		switch (m_State)
		{
		case AGENT_STATE_FREE:
			m_IsRepose = false;  // 2020-04-03 根据安图修改 座席置忙外呼后座席设置置忙
			__reportStatus();    // 2020-04-03 根据安图修改 座席置忙外呼后座席设置置忙
			return TRUE;
			break;
		case AGENT_STATE_BUSY:
		{
			if (IsForce)
				__onStatusUpdate(AGENT_STATE_BUSY, false);
			else
				return FALSE;
		}
		break;
		case AGENT_STATE_POST_PROCESSING:
		{
			__killTimer(TIMER_POST_PROCESSING);
			__onStatusUpdate(AGENT_STATE_POST_PROCESSING, false);
		}
		break;
		case AGENT_STATE_REPOSE:
		{
			__onStatusUpdate(AGENT_STATE_REPOSE, false);
			__onStatusUpdate(AGENT_STATE_FREE, true);    // 2021 - 11 - 22 保存坐席空闲状态开始
			m_IsRepose = false;
		}
		break;
		case AGENT_STATE_REQUESTED:
		{
			if (IsForce)
				__killTimer(TIMER_LOCK_PERIOD);
			else
				return FALSE;
		}
		break;

		case AGENT_STATE_LOGOUT:
			return FALSE;
			break;
		}

		m_State = m_IsRepose ? AGENT_STATE_REPOSE : AGENT_STATE_FREE;
	}
	break;

	case AGENT_STATE_REQUESTED:		// 被请求
	{
		ASSERT(m_State == AGENT_STATE_FREE);
		switch (m_State)
		{
		case AGENT_STATE_REQUESTED:
		case AGENT_STATE_BUSY:
		case AGENT_STATE_REPOSE:
		case AGENT_STATE_POST_PROCESSING:
		case AGENT_STATE_LOGOUT:
			__reportStatus();    // 2020-04-03 根据安图修改 座席置忙外呼后座席设置置忙
			return FALSE;
			break;
		}

		if (AGENT_STATE_FREE == m_State)
			__onStatusUpdate(AGENT_STATE_FREE, false);    // 2021-11-22 添加保存坐席空闲->被请求，空闲结束

		__setTimer(TIMER_LOCK_PERIOD, CConfig::agentLockedPeriod() * 1000);		// 被请求超时处理定时器
		m_State = AGENT_STATE_REQUESTED;

		__onStatusUpdate(AGENT_STATE_REQUESTED, true);    // 2021-11-22 添加保存坐席被请求开始,外线呼入锁定坐席

	}
	break;

	default:
	{
		switch (m_State)
		{
		case AGENT_STATE_BUSY:
			__onStatusUpdate(AGENT_STATE_BUSY, false);
			break;
		case AGENT_STATE_POST_PROCESSING:
		{
			__killTimer(TIMER_POST_PROCESSING);
			__onStatusUpdate(AGENT_STATE_POST_PROCESSING, false);
		}
		break;
		case AGENT_STATE_REPOSE:
		{
			m_IsRepose = false;
			__onStatusUpdate(AGENT_STATE_REPOSE, false);
		}
		break;
		case AGENT_STATE_REQUESTED:
			//__killTimer(TIMER_LOCK_PERIOD);
			if (a_AgentState != AGENT_STATE_LOGOUT)   // 2020-04-03 根据安图修改 座席置忙外呼后座席设置置忙
			{
				__killTimer(TIMER_LOCK_PERIOD);
			}
			else // 被请求或者座席锁定签出失败
			{
				if (!IsForce)  // 如果强制签出时，返回true
					return FALSE;
			}
			break;
		}

		m_State = a_AgentState;
	}
	break;
	} // end switch

	// 通知座席当前状态变化
	__reportStatus();
	__onStatusUpdate(m_State, true);
	return TRUE;
}

bool CAgent::sendState(AGENT_STATE a_AgentState)
{

	switch (a_AgentState)
	{
	case AGENT_STATE_FREE:			// 空闲
	{
		if (m_IsRepose)
		{
			m_State = AGENT_STATE_REPOSE;
		}
		__reportStatus();
	}
	case AGENT_STATE_REPOSE:        // 小休
	{
		__onStatusUpdate(AGENT_STATE_REQUESTED, false);
		__onStatusUpdate(m_State, true);
		__reportStatus();
	}
	break;
	}
	return false;
}

BOOL CAgent::setFreeForAgentCall(bool IsForce)
{
	switch (m_State)
	{
	case AGENT_STATE_FREE:
		return TRUE;
		break;
	case AGENT_STATE_BUSY:
	{
		if (IsForce)
		{
			__onStatusUpdate(AGENT_STATE_BUSY, false);
		}
		else
			return FALSE;
	}
	break;
	case AGENT_STATE_POST_PROCESSING:
	{
		__killTimer(TIMER_POST_PROCESSING);
		__onStatusUpdate(AGENT_STATE_POST_PROCESSING, false);
	}
	break;
	case AGENT_STATE_REPOSE:
	{
		__onStatusUpdate(AGENT_STATE_REPOSE, false);
		//m_IsRepose = false;
	}
	break;
	case AGENT_STATE_REQUESTED:
	{
		if (IsForce)
		{
			__killTimer(TIMER_LOCK_PERIOD);
			__onStatusUpdate(AGENT_STATE_REQUESTED, false);   // 2021-1-22 保存坐席状态，被请求结束
		}
		else
			return FALSE;
	}
	break;

	case AGENT_STATE_LOGOUT:
		return FALSE;
		break; 
	}

	// 2021-11-22
	AGENT_STATE state = m_State;

	// 2021-11-19 添加if条件 小休情况下，通话后仍为小休   2022-06-23 添加状态为被请求（外呼时，被叫拒接）,由通话中改为通话中或被请求为真
	if (m_IsRepose &&IsForce && (m_State == AGENT_STATE_BUSY || m_State == AGENT_STATE_REQUESTED))
		m_State = AGENT_STATE_REPOSE;
	else
		m_State = AGENT_STATE_FREE;

	if (IsForce && ((m_State == AGENT_STATE_FREE && state != AGENT_STATE_FREE) || (m_State == AGENT_STATE_REPOSE && state != AGENT_STATE_REPOSE)) && (state == AGENT_STATE_REQUESTED && state == AGENT_STATE_BUSY))  // 2021-11-22 添加保存坐席通话结束后的状态（闲/忙）开始   （被请求不处理（锁定超时））
	{
		__onStatusUpdate(m_State, true);    // 2021-11-22 添加保存坐席通话结束后的状态（闲/忙）开始
	}

	//if (m_IsRepose == false)  //2021-11-23 小休状态下外呼后向前端推送小休的坐席状态
	if ((m_IsRepose == false && (m_AssoExtState!= INNER_STATE_RING_BACK|| m_AssoExtState != INNER_STATE_ALERTING)) || state == AGENT_STATE_BUSY)
	{
		__reportStatus();
	}

	return TRUE;
}

BOOL CAgent::setRequestedForAgentCall(bool IsForce)
{
	ASSERT(m_State == AGENT_STATE_FREE);
	switch (m_State)
	{
	case AGENT_STATE_REQUESTED:
	case AGENT_STATE_BUSY:
	case AGENT_STATE_REPOSE:
	case AGENT_STATE_POST_PROCESSING:
	case AGENT_STATE_LOGOUT:
		return FALSE;
		break;
	}

	__onStatusUpdate(AGENT_STATE_FREE, false);    // 2021-11-22 添加保存坐席空闲结束，变为被请求

	__setTimer(TIMER_LOCK_PERIOD, CConfig::agentLockedPeriod() * 1000);		// 被请求超时处理定时器
	m_State = AGENT_STATE_REQUESTED;
	__onStatusUpdate(AGENT_STATE_REQUESTED, true);    // 2021-11-22 添加保存坐席被请求开始,系统外呼锁定当前坐席
	if (m_IsRepose == false)
		__reportStatus();

	return TRUE;
}

BOOL CAgent::setBusyForAgentCall(bool IsForce)
{
	if (IsForce && (m_State == AGENT_STATE_FREE || m_State == AGENT_STATE_REPOSE))  // 2021-11-22 添加保存坐席通话结束后的状态（闲/忙）结束
	{
		__onStatusUpdate(m_State, false);    // 2021-11-22 添加保存坐席通话结束后的状态（闲/忙）结束
	}

	switch (m_State)
	{
	case AGENT_STATE_BUSY:
		return TRUE;
		break;
	case AGENT_STATE_REQUESTED:
		__killTimer(TIMER_LOCK_PERIOD);
		break;
	case AGENT_STATE_POST_PROCESSING:
	{
		__killTimer(TIMER_POST_PROCESSING);
		__onStatusUpdate(AGENT_STATE_POST_PROCESSING, false);
	}
	break;
	case AGENT_STATE_REPOSE:
	{
		//m_IsRepose = false;
		__onStatusUpdate(AGENT_STATE_REPOSE, false);
	}
	break;
	case AGENT_STATE_LOGOUT:
		return FALSE;
		break;
	}

	__onStatusUpdate(AGENT_STATE_BUSY, true);
	m_State = AGENT_STATE_BUSY;

	if (m_IsRepose == false)
		__reportStatus();

	return TRUE;
}

BOOL CAgent::setProcessingForAgentCall(bool IsForce)
{
	switch (m_State)
	{
	case AGENT_STATE_POST_PROCESSING:
		return TRUE;
		break;
	case AGENT_STATE_BUSY:
		__onStatusUpdate(AGENT_STATE_BUSY, false);
		break;
	case AGENT_STATE_FREE:
	case AGENT_STATE_REPOSE:
	case AGENT_STATE_REQUESTED:
	case AGENT_STATE_LOGOUT:
		return FALSE;
		break;
	}
	// 统计话后处理开始
	__onStatusUpdate(AGENT_STATE_POST_PROCESSING, true);
	m_State = AGENT_STATE_POST_PROCESSING;
	if (m_TimePostProcessing > 0)
		__setTimer(TIMER_POST_PROCESSING, m_TimePostProcessing * 1000);		// 启动话后处理定时器
	
		
	//if (m_IsRepose == false)  // 2022-02-24 置忙下的外呼后，话后处理状态，因此屏蔽 取消置忙标识
	   m_IsRepose = false;
		__reportStatus();

	return TRUE;
}

/*****************************************************************
**【函数名称】	onAssoExtStatusUpdated
**【函数功能】	关联分机状态更新的处理函数
**【参数】		a_ExtState：分机当前状态
				Param：附加参数
**【返回值】
****************************************************************/
void CAgent::onAssoExtStatusUpdated(INNER_STATE a_ExtState, PARAM Param /*= NULL*/)
{
	CPduEntity * pCmd = (CPduEntity *)Param;

	m_AssoExtState = a_ExtState;
	switch (a_ExtState)
	{
	case INNER_STATE_ALERTING:
	{
		if (m_State == AGENT_STATE_POST_PROCESSING || m_State == AGENT_STATE_REPOSE /*|| m_State == AGENT_STATE_REQUESTED*/)
			setFreeForAgentCall(true);
			//setState(AGENT_STATE_FREE, true);
	}
	break;

	case INNER_STATE_RING_BACK:
	{
		if (m_State == AGENT_STATE_POST_PROCESSING || m_State == AGENT_STATE_REPOSE /*|| m_State == AGENT_STATE_REQUESTED*/) //2021-11-24 外呼被请求多了个空闲推送
			setFreeForAgentCall(true);
			//setState(AGENT_STATE_FREE, true);
	}
	break;

	case INNER_STATE_TALKING:
	{
		if (pCmd == NULL || pCmd->GetDataUInt(10) != PDU_CMD_AGENT_MONI_REPLACE)	// 如果是代接操作则不记录应答次数
			m_AnswerCount++;	// 累计应答计数
		//setState(AGENT_STATE_BUSY, true);
		setBusyForAgentCall(true);
	}
	break;

	case INNER_STATE_FREE:
	{
		if (m_State == AGENT_STATE_BUSY)
		{
			ASSERT(pCmd != NULL);
			setProcessingForAgentCall();
			/* 2022-02-28  通话中变空闲，状态为话后处理		
			// 关联线路为非内线，最后通话分机为当前分机，则需要进行话后处理
			if (pCmd != NULL && pCmd->GetDataUInt(7) != DEV_RES_TYPE_EXT && (pCmd->GetDataUInt(9) == m_Exten || pCmd->GetDataUInt(12) == 1))   // 2022-01-05 pdu-12 为是否在会议，在会议时最后应答分机不等于当前分机，也弹出
				//setState(AGENT_STATE_POST_PROCESSING);
				setProcessingForAgentCall();
			else
				//setState(AGENT_STATE_FREE, true);
				setFreeForAgentCall(true);
		   */
		}
		else if (m_State == AGENT_STATE_UNKNOWN || m_State == AGENT_STATE_REQUESTED)
			//setState(AGENT_STATE_FREE, true);
			setFreeForAgentCall(true);
		/*
		else if (m_State == AGENT_STATE_FREE &&!m_IsRepose)  // 2022-01-07 话机外呼失败，空闲变空闲，增加坐席状态回复空闲
			sendState(AGENT_STATE_FREE);
		else if (m_State == AGENT_STATE_FREE && m_IsRepose)  // 2022-07-07 置忙情况下话机外呼后，发送话机忙
			sendState(AGENT_STATE_REPOSE);
		else if(m_State == AGENT_STATE_REPOSE) // 2022-07-07 小休状态下外呼失败后，向坐席发送小休状态
			sendState(AGENT_STATE_REPOSE);
		*/
		else if(m_State == AGENT_STATE_FREE|| m_State == AGENT_STATE_REPOSE)
			sendState(m_State);
	}
	break;

	default:
	{
		if (m_State == AGENT_STATE_UNKNOWN)
			setState(AGENT_STATE_FREE);
	}
	break;
	}
}

/*****************************************************************
**【函数名称】	lock
**【函数功能】	锁定座席
**【参数】
**【返回值】
****************************************************************/
BOOL CAgent::lock(void)
{
	if (isFree())
		return setState(AGENT_STATE_REQUESTED);
	else
		return FALSE;
}

BOOL CAgent::lockForCall(void)
{
	if (isFreeForCall())
		return setRequestedForAgentCall();
	//return setState(AGENT_STATE_REQUESTED);
	else
		return FALSE;
}

void CAgent::GetAgentProperty(CAgentProperty& AgentProperty)
{
	AgentProperty.m_AnswerCount = m_AnswerCount;
	AgentProperty.m_ReposeCount = m_ReposeCount;
	AgentProperty.m_TimeFree = m_TimeFree;
	AgentProperty.m_TimePostProcessing = m_TimePostProcessing;
	AgentProperty.m_TimeRepos = m_TimeRepos;
	AgentProperty.m_TimeTalk = m_TimeTalk;
}

bool CAgent::queueJump()
{
	if (m_bFirstQueue) {
		m_bFirstQueue = false;
		return true;
	}
	else
	{
		return false;
	}

}