midware_ws/NetLib/ACD/AgentGroup.cpp

#include "StdAfx.h"
#include "AgentGroup.h"
#include "Agent.h"
#include "NetworkAcd.h"
#include "StrategyAD.h"
#include <algorithm>

CAgentGroup::CAgentGroup( void )
{
}


CAgentGroup::~CAgentGroup( void )
{
}

/*****************************************************************
**【函数名称】	add
**【函数功能】	添加座席
**【参数】
**【返回值】		
****************************************************************/
void CAgentGroup::add( CAgent* a_pAgent )
{
	ASSERT(a_pAgent != NULL);
	Add(a_pAgent);
}

/*****************************************************************
**【函数名称】	remove
**【函数功能】	删除座席
**【参数】
**【返回值】		
****************************************************************/
bool CAgentGroup::remove( CAgent* a_pAgent )
{
	ASSERT(a_pAgent != NULL);

	for(int i = 0; i < m_nSize; ++i)
	{
		if(m_pData[i] == a_pAgent)
		{
			RemoveAt(i, 1);
			TRACE(_T("Succeed @CAgentGroup::remove\r\n"));
			return true;
		}
	}

	return false;
}

/*****************************************************************
**【函数名称】	clear
**【函数功能】	释放所有座席
**【参数】
**【返回值】		
****************************************************************/
void CAgentGroup::clear( void )
{
	RemoveAll();
}

/*****************************************************************
**【函数名称】	isNoFreeAgent
**【函数功能】	是否座席全忙
**【参数】
**【返回值】		
****************************************************************/
bool CAgentGroup::isNoFreeAgent( void )
{
	for(int i = 0; i < m_nSize; ++i)	// 保证遍历一轮
	{
		if(m_pData[i]->isFree())
			return false;
	}
	return true;
}
int CAgentGroup::talkIngAgentCount()
{
	CAgent *pAgent = NULL;
	int count = 0;
	for (int idx = m_nSize; idx > 0; idx--) {
		pAgent = m_pData[0];
		if (pAgent->state()== AGENT_STATE_BUSY)
		{
			count += 1;
		}
	}
	return count;
}

//2018.6.14 for 严格循环
CAgent* CAgentGroup::GetFreeAgentForLoop()
{
	CAgent *pAgent = NULL;

	CString str;
	for (int idx = 0; idx < m_nSize; idx++) {
		str.Format("%s|%d|%s|%d", str, m_pData[idx]->id(), m_pData[idx]->group(), m_pData[idx]->isFree());
	}
	ILogger::getInstance().log(LOG_CLASS_SOCKET, LOG_LEVEL_NORMAL, "轮训排队信息[%s]", str);

	for (int idx = 0; idx < m_nSize; idx++) {
		pAgent = m_pData[idx];
		if (pAgent->isFree()) {
			RemoveAt(idx, 1);
			Add(pAgent);
			return pAgent;
		}
	}

	//for (int idx = m_nSize; idx > 0; idx-- ) {
	//	pAgent = m_pData[0];
	//	RemoveAt(0, 1);
	//	Add(pAgent);
	//	if (pAgent->isFree()) {
	//		return pAgent;  // ych
	//	}
	//}
	
	return NULL; // ych
}

CAgent * CAgentGroup::GetFreeAgentForLoopByAgentId()
{
	static UINT agentId = 0;  // 2020-01-13记录本次分配的座席id
	CAgent *pAgent = NULL;
	bool isExist = false;
	std::map<UINT, CAgent*> mAgents;
	for (size_t i = 0; i < m_nSize; i++)
	{
		pAgent = m_pData[i];
		mAgents.insert(std::pair<UINT, CAgent*>(pAgent->id(), pAgent));
	}

	auto it = mAgents.begin();
	while (it != mAgents.end())
	{
		if (it->first > agentId && it->second->isFree())
		{
			agentId = it->first;
			isExist = true;
			break;
		}
		++it;
	}
	if (isExist = false)
	{
		it = mAgents.begin();
		while (it != mAgents.end())
		{
			if (it->first <= agentId && it->second->isFree())
			{
				agentId = it->first;
				isExist = true;
				break;
			}
			if (it->first > agentId)
			{
				break;
			}
			++it;
		}
	}
	if (isExist = true)
	{
		for (size_t i = 0; i < m_nSize; i++)
		{
			pAgent = m_pData[i];
			if (m_pData[i]->id() == agentId)
				return m_pData[i];
		}
	}
	return NULL;

	// ----------------------

	CArray<CAgent*,CAgent*> *agent = this;
	std::sort(this->GetData(), this->GetData() + this->GetSize(), [&](CAgent *a, CAgent *b) mutable ->bool { return a->id() < b->id(); });
	for (int i = 0; i < m_nSize; i++)
	{
		pAgent = m_pData[i];
		if (pAgent->isFree()&&pAgent->id()> agentId)
		{
			agentId = pAgent->id();
			return pAgent;
		}
	}
	for (int i = 0; i < m_nSize; i++)
	{
		pAgent = m_pData[i];
		if (pAgent->isFree() && pAgent->id() <= agentId) 
		{
			agentId = pAgent->id();
			return pAgent;  
		}
	}
	return nullptr;
}

std::string CAgentGroup::GetCurAllAgent()
{
	CString str;
	std::stringstream ss;
	for (int idx = 0; idx < m_nSize; idx++) {
		//str.Format("%s#%d|%d|%s|%d", str, m_pData[idx]->id(), m_pData[idx]->assoExten(),  m_pData[idx]->group(), m_pData[idx]->type());
		ss << m_pData[idx]->id()<<"|";
		ss << m_pData[idx]->assoExten() << "|";
		ss << m_pData[idx]->group() << "|";
		ss << m_pData[idx]->type() << "#";
	}

	return ss.str();
}

/*****************************************************************
**【函数名称】	distributeAgent
**【函数功能】	分派座席
**【参数】
**【返回值】		
****************************************************************/
QUEUE_AGENT_RESULT CAgentGroup::distributeAgent( CStrategyAD* pStrategy, const CString& InfoEx, UINT& Agent, UINT& Exten )
{
	if(m_nSize == 0)
		return QUEUE_AGENT_FAILED_NO_AGENT;

	// 如果座席全忙
	if(isNoFreeAgent()) 
		return QUEUE_AGENT_FAILED_NO_FREE;

	CAgent* pAgent = NULL;

	QUEUE_AGENT_RESULT Result = pStrategy->distributeAgent(*this, InfoEx, pAgent);
	if(pAgent != NULL && pAgent->lock())	// 对于无法锁定的座席，默认分配失败
	{
		Agent = pAgent->id();
		Exten = pAgent->assoExten();
		return Result;
	}
	else
	{
		return QUEUE_AGETN_FAILED_NO_SPEC;
	}
}