hopekingdatabase.cpp

IVR交互式语音应答系统脚本解析器

	m_OdbcDataMap.SetAt(pDbs->m_csAlis,(void *)NULL);
	for(int i=0;i<m_ListOdbcData.GetSize();i++){
		if(pDbs==m_ListOdbcData[i]){
			m_ListOdbcData.RemoveAt(i);
			break;
		}
	}
	LeaveCriticalSection(&statArea);
	try{
		pDbs->CloseData();
		delete pDbs;
	}
	catch(...){
	}
	return;
}

CDistrabutorMg::CDistrabutorMg(CDataBus * pBus):CAsynWorker(pBus)
{
	InitializeCriticalSection(&statArea);
};

CDistrabutorMg::~CDistrabutorMg()
{
	for(int i=0;i<m_ListDistrData.GetSize();i++){
		if(m_ListDistrData[i]->IsValid()){
			delete m_ListDistrData[i];
		}
	}
	m_ListDistrData.RemoveAll();
	DeleteCriticalSection(&statArea);
}

CResDistrabutor * CDistrabutorMg::OpenDistrabutor(LPCTSTR szName,int GroupNum,LPCTSTR szFeatureList,int timeout,int length)
{
	if(!szName||!szName[0])return NULL;
	EnterCriticalSection(&statArea);
	CResDistrabutor * pDistr=GetDistrabutor(szName);
	if(pDistr){
		LeaveCriticalSection(&statArea);
		return pDistr;
	}
	pDistr=new CResDistrabutor(m_pBus);
	m_ListDistrData.Add(pDistr);
	pDistr->PointeRoad(1);
	try{
		m_DistrMap.SetAt(szName,(void *)pDistr);
		pDistr->m_csName=szName;
		pDistr->m_iTimeout=timeout;
		pDistr->m_iMaxLength=length;
		pDistr->m_iMaxGroupNum=GroupNum;
		if(pDistr->m_iMaxGroupNum<0)pDistr->m_iMaxGroupNum=0;
		if(pDistr->m_iMaxGroupNum>MAX_GROUP_NUM)pDistr->m_iMaxGroupNum=MAX_GROUP_NUM;
		if(pDistr->m_iMaxGroupNum){
			pDistr->pdwGroupCountF=new DWORD[pDistr->m_iMaxGroupNum];
			pDistr->pdwGroupCountN=new DWORD[pDistr->m_iMaxGroupNum];
			pDistr->pdwGroup=new DWORD[pDistr->m_iMaxGroupNum];
			memset(pDistr->pdwGroupCountF,0,sizeof(DWORD)*pDistr->m_iMaxGroupNum);
			memset(pDistr->pdwGroupCountN,0,sizeof(DWORD)*pDistr->m_iMaxGroupNum);
			memset(pDistr->pdwGroup,0,sizeof(DWORD)*pDistr->m_iMaxGroupNum);
		}
		else {
			pDistr->pdwGroupCountF=NULL;
			pDistr->pdwGroupCountN=NULL;
			pDistr->pdwGroup=NULL;
		}
		pDistr->m_iMaxFeatureNum=pDistr->AddFeatureName(szFeatureList);
		if(pDistr->m_iMaxFeatureNum){
			pDistr->pdwFeatureCountF=new DWORD[pDistr->m_iMaxFeatureNum];
			pDistr->pdwFeatureCountN=new DWORD[pDistr->m_iMaxFeatureNum];
			memset(pDistr->pdwFeatureCountF,0,sizeof(DWORD)*pDistr->m_iMaxFeatureNum);
			memset(pDistr->pdwFeatureCountN,0,sizeof(DWORD)*pDistr->m_iMaxFeatureNum);
		}
		else {
			pDistr->pdwFeatureCountF=NULL;
			pDistr->pdwFeatureCountN=NULL;
		}
	}
	catch(...){
	}
	LeaveCriticalSection(&statArea);
	return pDistr;
}

void CDistrabutorMg::CloseDistrabutor(CResDistrabutor * pDistr)
{
	if(!pDistr->IsValid())
		return;
	EnterCriticalSection(&statArea);
	try{
		CString csa=pDistr->m_csName;
		if(pDistr!=GetDistrabutor(csa)){
			LeaveCriticalSection(&statArea);
			return;
		}
	}
	catch(...){
		LeaveCriticalSection(&statArea);
		return;
	}
	m_DistrMap.SetAt(pDistr->m_csName,(void *)NULL);
	for(int i=0;i<m_ListDistrData.GetSize();i++){
		if(pDistr==m_ListDistrData[i]){
			m_ListDistrData.RemoveAt(i);
			break;
		}
	}
	LeaveCriticalSection(&statArea);
	try{
		delete pDistr;
	}
	catch(...){
	}
	return;
}

CResDistrabutor::CResDistrabutor(CDataBus * pBus):CAsynWorker(pBus)
{
	dwSkillStatusF=dwSkillStatusN=0;
	AddTime(5,0,false,false);
}

CResDistrabutor::~CResDistrabutor()
{
	CancelTime(0);
	if(pdwGroupCountF)
		delete [] pdwGroupCountF;
	if(pdwGroupCountN)
		delete [] pdwGroupCountN;
	if(pdwFeatureCountF)
		delete [] pdwFeatureCountF;
	if(pdwFeatureCountN)
		delete [] pdwFeatureCountN;
	if(pdwGroup)
		delete [] pdwGroup;
	for(int i=0;i<m_ResList.GetSize();i++){
		if(m_ResList[i].pbtSkillLevel)
			delete [] m_ResList[i].pbtSkillLevel;
	}
}

int CResDistrabutor::AddFeatureName(LPCTSTR szFeature)
{
	CString csFeat=szFeature,cs;
	int iFeatCount=0;
	while(iFeatCount<MAX_FEATURE_NUM&&!csFeat.IsEmpty()){
		int i=csFeat.Find(",");
		if(i>0){
			cs=csFeat.Left(i);
		}
		else if(i<0){
			cs=csFeat;
		}
		else {
			cs="";
		}
		cs.TrimLeft();
		cs.TrimRight();
		if(!cs.IsEmpty()){
			m_StringFeatureList.SetAt(cs,(void *)(iFeatCount));
			iFeatCount++;
		}
		csFeat=csFeat.Right(csFeat.GetLength()-i-1);
	}
	return iFeatCount;
}

DWORD CResDistrabutor::GetSkillLevel(BYTE * pLevel,LPCTSTR szFeature)
{
	DWORD iFeatCount=0;
	if(!szFeature||!szFeature[0])return iFeatCount;
	CString csFeat=szFeature,cs;
	int ift=0;
	int icount=0;
	int posx=0;
	while(iFeatCount<MAX_FEATURE_NUM&&!csFeat.IsEmpty()){
		int i=csFeat.Find(",");
		if(i>0){
			cs=csFeat.Left(i);
		}
		else if(i<0){
			cs=csFeat;
		}
		else {
			cs="";
		}
		cs.TrimLeft();
		cs.TrimRight();
		if(!cs.IsEmpty()){
			if(pLevel){
				CString cs1="";
				int j=cs.Find("|");
				if(j>0){
					cs1=cs;
					cs=cs.Left(j);
					cs1=cs1.Right(cs1.GetLength()-j-1);
				}
				else if(j==0){
					continue;
				}
				posx=atoi(cs1);
			}
			if(m_StringFeatureList.Lookup(cs,(void * &)(ift))){
				iFeatCount+=1<<ift;
				if(pLevel)
					pLevel[ift]=(BYTE)posx;
				icount++;
				if(icount>=m_iMaxFeatureNum)break;
			}
		}
		csFeat=csFeat.Right(csFeat.GetLength()-i-1);
	}
	return iFeatCount;
}

void CResDistrabutor::AddRes(DWORD dwGroupId,LPCTSTR szSkillFeature,DWORD dwResKey,DWORD dwCatchObj,DWORD dwCatchMod)
{
	int i;
	if(m_ResKeyList.Lookup((void *)dwResKey,(void * &)i))return;
	i=m_ResList.GetSize();
	BYTE btAry[MAX_FEATURE_NUM];
	memset(btAry,0,MAX_FEATURE_NUM);
	RESOBJ res;
	m_ResList.Add(res);
	m_ResList[i].dwGroupId=dwGroupId;
	m_ResList[i].dwFeaturesId=GetSkillLevel(btAry,szSkillFeature);
	m_ResList[i].dwResKey=dwResKey;
	m_ResList[i].dwTmCount=0;
	m_ResList[i].tm=0;
	m_ResList[i].dwCatchObj=dwCatchObj;
	m_ResList[i].dwCatchMod=dwCatchMod;
	if(m_ResList[i].dwFeaturesId){
		m_ResList[i].pbtSkillLevel=new BYTE[m_iMaxFeatureNum];
		memcpy(m_ResList[i].pbtSkillLevel,btAry,m_iMaxFeatureNum);
	}
	else{
		m_ResList[i].pbtSkillLevel=NULL;
	}
	m_ResList[i].dwGroupPos=GetGroupPos(dwGroupId);
	m_ResKeyList.SetAt((void *)dwResKey,(void * )i);
}

BOOL CResDistrabutor::AddNeeder(BOOL bAsyn,DWORD dwIdent,DWORD dwObj,DWORD dwMod,DWORD dwNeedKey1,DWORD dwNeedKey2,DWORD dwType,DWORD dwId,DWORD dwRight)
{
	DWORD ipos=GetGroupPos(dwId);
	if(ipos==0xffffffff||!pdwGroupCountF)return FALSE;
	if(dwType!=0x10&&dwType!=0x11)return FALSE;
	//dwType==0x12 抢答
	int itp=-1;
	int icount=(int)pdwGroupCountF[ipos];
	if(pdwGroupCountF&&icount){
		POSITION pos=m_FreeResList.GetHeadPosition(),pos1=pos;
		while(pos){
			pos1=pos;
			int ip=m_FreeResList.GetNext(pos);
			if(m_ResList[ip].dwGroupId==dwId){
				if(itp!=-1){
					if(dwType==0x10){
						if(m_ResList[ip].tm<m_ResList[ip].tm){
							itp=ip;
						}
					}
					else if(dwType==0x11){
						if(m_ResList[ip].dwTmCount<m_ResList[ip].dwTmCount){
							itp=ip;
						}
					}
					else if(dwType==0x12){
						//send callcoming apply抢答
					}
				}
				else {
					if(dwType==0x12){
						if(icount>1){
							//send callcoming apply抢答
						}
						itp=ip;
					}
					else{
						itp=ip;
					}
				}
				icount--;
				if(icount)break;
			}
		}
		if(itp!=-1){
			m_FreeResList.RemoveAt(pos1);
			m_ResKeyPos.SetAt((void *)m_ResList[itp].dwResKey,(void *)NULL);
			m_ResList[itp].tm=GetTimeStamp();
			if(m_ResList[itp].dwGroupPos!=0xffffffff){
				pdwGroupCountF[m_ResList[itp].dwGroupPos]--;
			}
			if(m_ResList[itp].dwFeaturesId){
				CheckFCount(-1,m_ResList[itp].dwFeaturesId,pdwFeatureCountF,dwSkillStatusF);
			}
			//post message for distrabute
			if(bAsyn==1){
				SetSynMsgReturn(dwMod,
					(CAsynWorker *)dwObj,
					CMD_APPLY_RES,
					UniVar(m_ResList[itp].dwResKey),
					UniVar(dwNeedKey1),
					UniVar(dwNeedKey2),
					UniVar(m_csName),
					InValidVar);
			}
			else{
				CUniMsg um;
				um.m_dwCommand=CMD_APPLY_RES;
				if(bAsyn==0)
					um.m_btMsgType=MSG_RESPONSE;
				else
					um.m_btMsgType=MSG_EVENT;
				um.m_dwSendMode=GetModId();
				um.m_pSender=this;
				um.m_dwReceiveMode=dwMod;
				um.m_pReceivor=(CAsynWorker *)dwObj;
				um.m_dwIdent=dwIdent;
				um.Add(m_ResList[itp].dwResKey);
				um.Add(dwNeedKey1);
				um.Add(dwNeedKey2);
				um.Add(m_csName);
				m_pBus->SendMessage(&um,m_btCurRoad);
			}
			return TRUE;
		}
	}
	if(bAsyn==1){
		return FALSE;
	}
	if(pdwGroupCountN[ipos]>=(DWORD)m_iMaxLength){
		return FALSE;
	}
	pdwGroupCountN[ipos]++;
	NEEDER nr;
	for(int i=0;i<m_NeederListG.GetSize();i++){
		if(m_NeederListG[i].dwRight==dwRight){
			m_NeederListG.InsertAt(i,nr);
			break;
		}
	}
	if(i==m_NeederListG.GetSize()){
		m_NeederListG.Add(nr);
	}
	m_NeederListG[i].dwRight=dwRight;
	m_NeederListG[i].dwObj=dwObj;
	m_NeederListG[i].dwMod=dwMod;
	m_NeederListG[i].dwNeedKey1=dwNeedKey1;
	m_NeederListG[i].dwNeedKey2=dwNeedKey2;
	m_NeederListG[i].dwIdent=dwIdent;
	m_NeederListG[i].dwType=dwType;
	m_NeederListG[i].bAsyn=bAsyn;
	m_NeederListG[i].dwId=dwId;
	m_NeederListG[i].tm=GetTimeStamp();
	return TRUE;
}

BOOL CResDistrabutor::AddNeeder(BOOL bAsyn,DWORD dwIdent,DWORD dwObj,DWORD dwMod,DWORD dwNeedKey1,DWORD dwNeedKey2,DWORD dwType,LPCTSTR szFeature,DWORD dwRight)
{
	DWORD dwSkillId=GetSkillLevel(NULL,szFeature);
	if(!dwSkillId||!pdwFeatureCountF)return TRUE;
	if(dwType!=0x00&&dwType!=0X01)return FALSE;
	DWORD dwTempSkillid=dwSkillStatusF,dwTempSkillCount[MAX_FEATURE_NUM];
	memset(dwTempSkillCount,0,sizeof(DWORD)*MAX_FEATURE_NUM);
	memcpy(dwTempSkillCount,pdwFeatureCountF,sizeof(DWORD)*m_iMaxFeatureNum);
	if((dwType==0x00&&(dwTempSkillid&dwSkillId)==dwSkillId)||(dwType==0x01&&(dwTempSkillid&dwSkillId))){
		int itp=-1;
		POSITION pos=m_FreeResList.GetHeadPosition(),pos1=pos;
		int itempSkl1=0,itempSkl2=0;
		while(pos){
			pos1=pos;
			int ip=m_FreeResList.GetNext(pos);
			BOOL bSuc=FALSE;
			if(m_ResList[ip].dwFeaturesId){
				if(dwType==0x00){
					if((m_ResList[ip].dwFeaturesId&dwSkillId)==dwSkillId){
						bSuc=TRUE;
					}								
				}
				else {
					if(m_ResList[ip].dwFeaturesId&dwSkillId){
						bSuc=TRUE;
					}
				}
				CheckFCount(-1,m_ResList[ip].dwFeaturesId,dwTempSkillCount,dwTempSkillid);
				if((dwType==0x00&&(dwTempSkillid&dwSkillId)==dwSkillId)||(dwType==0x01&&(dwTempSkillid&dwSkillId))){
					if(bSuc){
						if(itp==-1){
							itp=ip;
							itempSkl1=GetSkillLevel(ip);
						}
						else{
							itempSkl2=itempSkl1;
							itempSkl1=GetSkillLevel(ip);
							if(itempSkl2<itempSkl1){
								itp=ip;
							}
						}
					}
				}
				else{
					if(itp==-1&&bSuc){
						itp=ip;
					}
					break;
				}
			}
		}
		if(itp!=-1){
			m_FreeResList.RemoveAt(pos1);
			m_ResKeyPos.SetAt((void *)m_ResList[itp].dwResKey,(void *)NULL);
			m_ResList[itp].tm=GetTimeStamp();
			if(m_ResList[itp].dwGroupPos!=0xffffffff){
				pdwGroupCountF[m_ResList[itp].dwGroupPos]--;
			}
			if(m_ResList[itp].dwFeaturesId){
				CheckFCount(-1,m_ResList[itp].dwFeaturesId,pdwFeatureCountF,dwSkillStatusF);
			}
			//post message for distrabute
			if(bAsyn==1){
				SetSynMsgReturn(dwMod,
					(CAsynWorker *)dwObj,
					CMD_APPLY_RES,
					UniVar(m_ResList[itp].dwResKey),
					UniVar(dwNeedKey1),
					UniVar(dwNeedKey2),
					UniVar(m_csName),
					InValidVar);
			}
			else{
				CUniMsg um;
				um.m_dwCommand=CMD_APPLY_RES;
				if(bAsyn==0)
					um.m_btMsgType=MSG_RESPONSE;
				else
					um.m_btMsgType=MSG_EVENT;
				um.m_dwSendMode=GetModId();
				um.m_pSender=this;
				um.m_dwReceiveMode=dwMod;
				um.m_pReceivor=(CAsynWorker *)dwObj;
				um.m_dwIdent=dwIdent;
				um.Add(m_ResList[itp].dwResKey);
				um.Add(dwNeedKey1);
				um.Add(dwNeedKey2);
				um.Add(m_csName);
				m_pBus->SendMessage(&um,m_btCurRoad);
			}
			return TRUE;
		}
	}
	if(bAsyn==1){
		return FALSE;
	}
	NEEDER nr;
	CheckFCount(1,dwSkillId,pdwFeatureCountN,dwSkillStatusN);
	for(int i=0;i<m_NeederListS.GetSize();i++){
		if(m_NeederListS[i].dwRight==dwRight){