dominohandler.cpp

基于domino系统邮件数据库编写的邮件助手程序

	m_rgstrServiceResultMsg[1] = "";

	//拼请求服务字符串
	CString strServiceRequest = "";
	for ( int i=0; i<MAX_DOMINO_SERVICE; i++ ) {
		if ( m_rgstrServiceEnabled[i] != "" ) {
			strServiceRequest += ((strServiceRequest=="")?"":";") +  m_rgstrServiceEnabled[i];
		}
	}
	//strServiceRequest = CURLEncode::URLEncode( strServiceRequest );	//无需编码
	//发送请求
	CString s; s.Format("%d", m_nRequestCnt );
	m_oReqParm.nHttpVerb = CHttpConnection::HTTP_VERB_GET;
	m_oReqParm.sUrl  = m_strDominoServicePath + "&Action=getservice&ServiceNames=" + strServiceRequest + "&ReqCnt=" + s;
	sendRequest( true );
	//计算结果
	if ( IsRequestSuccessed() ) {
		//解析
		parseServiceResult( m_rgstrServiceResultMsg );
		//成功服务请求次数加1
		if ( m_rgstrServiceResultMsg[0] != "" ) {
			m_nRequestCnt ++;
		}
		//返回
		return m_rgstrServiceResultMsg[0];
	} else if ( !bForceLogin ) { // IsSessionTimeout() &&
		//避免死循环
		if ( Login() ) {
			return GetServiceMsg( true );
		}
	}

	return "";
	//返回错误消息－不包括链接失效（超时/用户名密码错等）消息（空）
	//return GetRequestResult();
}
CString CDominoHandler::GetServiceMsgSimple()
{
	return m_rgstrServiceResultMsg[1];
}

//新建线程提交http请求
//bWait：是否等待线程结束，默认为false
void CDominoHandler::sendRequest( bool bWait )
{
	//MessageBox(NULL, "CDominoHandler::sendRequest", "", MB_OK);
	
	//ft，老从缓存读。url后加个随机数：当前时间，精确到分钟
	if ( m_oReqParm.sUrl != "" ) {
		char sTime[30];
		time_t t;
		time(&t);
		tm* tmNow = localtime(&t);
		sprintf( sTime, "%04d%02d%02d%02d%02d\0",
				 tmNow->tm_year+1900, tmNow->tm_mon+1, tmNow->tm_mday, tmNow->tm_hour, tmNow->tm_min );
		m_oReqParm.sUrl += "&";
		m_oReqParm.sUrl += sTime;
	}
	
	//创建线程
	CHttpRequestThread* pThread = new CHttpRequestThread();
	pThread->SetParm( &m_oReqParm );
	pThread->CreateThread();

	//等待线程结束
	if ( bWait ) {
		WaitForSingleObject ( pThread->m_hThread, INFINITE );
		//MessageBox( NULL, "exit thread", "", MB_OK );
	}
}

////////////////////////////////////////////////////////////////////////

//根据服务名称，从服务列表中读取服务位置
inline int getIndex( CString* rgstr, CString str, int nCnt )
{
	for ( int i=0; i<nCnt; i++ ) {
		if ( rgstr[i] == str )
			return i;
	}
	return -1;
}
int CDominoHandler::getServiceIndexDisabled( CString strServiceName )
{
	return getIndex( m_rgstrServiceDisabled, strServiceName, MAX_DOMINO_SERVICE );
}
int CDominoHandler::getServiceIndexEnabled ( CString strServiceName )
{
	return getIndex( m_rgstrServiceEnabled, strServiceName, MAX_DOMINO_SERVICE );
}

//添加服务
bool CDominoHandler::addServiceEnabled( CString strServiceName )
{
	for ( int i=0; i<MAX_DOMINO_SERVICE; i++ ) {
		if ( m_rgstrServiceEnabled[i] == "" ) {
			m_rgstrServiceEnabled[i] = strServiceName;
			return true;
		}
	}
	return false;
}
bool CDominoHandler::addServiceDisabled(CString strServiceName )
{
	for ( int i=0; i<MAX_DOMINO_SERVICE; i++ ) {
		if ( m_rgstrServiceDisabled[i] == "" ) {
			m_rgstrServiceDisabled[i] = strServiceName;
			return true;
		}
	}
	return false;
}

bool CDominoHandler::AddService( CString strServiceName, bool bEnabled )
{
	//查找是否已添加先：）
	if ( getServiceIndexDisabled(strServiceName) != -1 
		|| getServiceIndexEnabled(strServiceName) != -1 ) {
		return false;
	}
	//添加
	bool bRet;
	if ( bEnabled ) {
		bRet = addServiceEnabled( strServiceName );
	} else {
		bRet = addServiceDisabled( strServiceName );
	}
	if ( bRet ) {
		m_nServiceCnt += (m_nServiceCnt==-1) ? 2 : 1;
	}
	return bRet;
}

CString* CDominoHandler::GetServiceEnabled()
{
	return m_rgstrServiceEnabled;
}
CString* CDominoHandler::GetServiceDisabled()
{
	return m_rgstrServiceDisabled;
}

//清空服务配置
bool CDominoHandler::ClearService()
{
	for ( int i=0; i<MAX_DOMINO_SERVICE; i++ ) {
		m_rgstrServiceEnabled[i]  = "";
		m_rgstrServiceDisabled[i] = "";
	}
	m_nServiceCnt = -1;
	return true;
}

//获得XML节点的属性值
inline CString getAttribute( IXMLDOMNode* n, CString strAttName )
{
	VARIANT varRet;
	IXMLDOMNamedNodeMap* nnm;
	if ( SUCCEEDED(n->get_attributes(&nnm)) ) {
		IXMLDOMNode *an = NULL;
		if ( SUCCEEDED(nnm->getNamedItem((_bstr_t)strAttName, &an)) && an!=NULL) {
			if ( SUCCEEDED(an->get_nodeValue(&varRet)) ) {
				an->Release();
				nnm->Release();
				return varRet.bstrVal;
			}
			an->Release();
		}
		nnm->Release();
	}
	return "";
}
//TODO: 解析服务器返回的结果
void CDominoHandler::parseServiceResult( CString* rgstrResult )
{
	CString strXML = GetRequestResult();
	
	//装载XML
	IXMLDOMDocument *pXMLDoc;
	VARIANT_BOOL bResult;
	if(SUCCEEDED(CoInitialize(NULL)) && SUCCEEDED(CoCreateInstance(CLSID_DOMDocument, 
		NULL, CLSCTX_INPROC_SERVER, IID_IXMLDOMDocument, (void**)&pXMLDoc))) {
		if(FAILED(pXMLDoc->loadXML( (_bstr_t)strXML, &bResult)))
			return;
	}
	IXMLDOMElement* base;
	pXMLDoc->get_documentElement(&base);
	if ( base == NULL ) return;

	//解析
	CString strRetSimp = "";	//简单返回服务标题
	CString strRetFull = "";	//返回详细内容
	IXMLDOMNodeList* nlService;
	base->selectNodes( (_bstr_t)"service", &nlService );
	long nServiceRetCnt;
	nlService->get_length( &nServiceRetCnt );
	for ( int i=0; i<nServiceRetCnt; i++ ) {
		IXMLDOMNode* nService;
		nlService->get_item(i, &nService);
		//服务的标题 title
		strRetSimp += getAttribute( nService, "title" ) + "。\n";
		strRetFull += getAttribute( nService, "title" );

		IXMLDOMNodeList* nlItems;
		nService->selectNodes( (_bstr_t)"items", &nlItems );
		long nItemsCnt;
		nlItems->get_length(&nItemsCnt);
		if ( nItemsCnt == 0 ) {
			strRetFull += "。\r\n";
		} else {
			strRetFull += "－\r\n";
		}
		for ( int j=0; j<nItemsCnt; j++ ) {
			IXMLDOMNode* nItems;
			nlItems->get_item( j, &nItems );
			IXMLDOMNodeList* nlItem;
			nItems->selectNodes( (_bstr_t)"item", &nlItem );
			long nItemCnt;
			nlItem->get_length( &nItemCnt );
			//取 title & content
			for ( int k=0; k<nItemCnt; k++ ) {
				IXMLDOMNode* nItem;
				nlItem->get_item( k, &nItem );

				IXMLDOMNode* nTitle;
				BSTR szTitle = NULL;
				nItem->selectSingleNode( (_bstr_t)"title", &nTitle );
				nTitle->get_text( &szTitle );
				nTitle->Release();
				
				IXMLDOMNode* nContent;
				BSTR szContent = NULL;
				nItem->selectSingleNode( (_bstr_t)"content", &nContent );
				nContent->get_text( &szContent );
				nContent->Release();

				nItem->Release();
				
				//拼一条结果
				strRetFull += szTitle;	//service配置文档中已包含冒号
				strRetFull += szContent;
				strRetFull += "\t";
			}
			strRetFull += "\r\n";
			nlItem->Release();
			nItems->Release();
		}
		strRetFull += "\r\n";
		nlItems->Release();
		nService->Release();
	}	
	nlService->Release();
	base->Release();
	pXMLDoc->Release();

	rgstrResult[0] = strRetFull;
	rgstrResult[1] = strRetSimp;
}

//解析服务配置，返回可用服务数
int CDominoHandler::parseService()
{
	// CString strXML, CString* rgName, int nServiceCnt 
	CString strXML = m_strServiceCfg;
	CString rgstrName[MAX_DOMINO_SERVICE];

	//装载XML
	IXMLDOMDocument *pXMLDoc;
	VARIANT_BOOL bResult;
	if(SUCCEEDED(CoInitialize(NULL)) && SUCCEEDED(CoCreateInstance(CLSID_DOMDocument, 
		NULL, CLSCTX_INPROC_SERVER, IID_IXMLDOMDocument, (void**)&pXMLDoc)))
	{
		if(FAILED(pXMLDoc->loadXML( (_bstr_t)strXML, &bResult)))
			return 0;
	}
	IXMLDOMElement* base;
	pXMLDoc->get_documentElement(&base);
	if ( base == NULL ) return 0;
	//解析
	IXMLDOMNodeList* resultList;
	IXMLDOMNode *nService;
	IXMLDOMNode *nName;
	BSTR szName = NULL;
	base->selectNodes( (_bstr_t)"service[@enabled=1]", &resultList );
	if ( resultList == NULL ) return 0;
	int nCnt = 0;
	for ( int i=0; i<MAX_DOMINO_SERVICE; i++ ) {
		resultList->get_item(i,&nService);
		if ( nService == NULL ) break;
		nService->selectSingleNode( (_bstr_t)"name", &nName );
		if ( nName!=NULL ) {
			nName->get_text( &szName );
//财政部邮件小秘书专版
#ifdef _MOFEM
			if ( ((CString)szName == "邮件") || ((CString)szName == "待办事宜") || ((CString)szName == "日历") ) {
				//添加到服务列表
				rgstrName[nCnt] = szName;
				if ( rgstrName[nCnt]!="" ) {
					nCnt ++;
				}
			}
//达奥小秘书
#else
			//添加到服务列表
			rgstrName[nCnt] = szName;
			if ( rgstrName[nCnt]!="" ) {
				nCnt ++;
			}
#endif
		}
	}
	base->Release();
	pXMLDoc->Release();
	//整理现有服务列表
	for ( i=0; i<nCnt; i++ ) {
		if ( getServiceIndexDisabled(rgstrName[i]) == -1
			&& getServiceIndexEnabled(rgstrName[i]) == -1 ) {
			AddService( rgstrName[i], true );
		}
	}
	for ( i=0; i<MAX_DOMINO_SERVICE; i++ ) {
		if ( getIndex( rgstrName, m_rgstrServiceEnabled[i], nCnt ) == -1 ) {
			m_rgstrServiceEnabled[i] = "";
		}
		if ( getIndex( rgstrName, m_rgstrServiceDisabled[i], nCnt ) == -1 ) {
			m_rgstrServiceDisabled[i] = "";
		}
	}
	//
	return nCnt;
}

//取得服务器的可以服务数
int CDominoHandler::GetServiceCnt()
{
	if ( m_nServiceCnt == -1 ) {
		GetServiceCfg();
	}
	return m_nServiceCnt;
}

//清空服务请求计数器
void CDominoHandler::ResetRequest()
{
	m_nRequestCnt = 1;
}

/*
//设置服务器的可用服务数
//保存服务配置时调用 - Called by CDominoMessage::SaveConfigServer
void CDominoHandler::SetServiceCnt( int nCnt )
{
	m_nServiceCnt = nCnt;
}
*/

//用户登陆后，初始化Domino连接
/*
	*1、测试用户名和密码是否能被探测到
					- 可以，使用IE也不能幸免，不过如果用户名/密码域改名（编码）可能会被嗅探器忽略
		https呢		- 不行 ^_^
	*2、GetUTF8函数
	*3、保持链接
	*4、退出
	*5、捕捉错误：超时(1)，验证错误(2)等
*/



/* 编码不对：（

//////////////////////////////////////////////////////////////////////
// URLEncode	 http://www.codeproject.com/string/urlencode.asp
//////////////////////////////////////////////////////////////////////
inline BYTE toHex(const BYTE &x)
{
	return x > 9 ? x + 55: x + 48;
}
CString URLEncode(CString sIn)
{
	CString sOut;
	const int nLen = sIn.GetLength() + 1;

	register LPBYTE pOutTmp = NULL;
	LPBYTE pOutBuf = NULL;
	register LPBYTE pInTmp = NULL;
	LPBYTE pInBuf =(LPBYTE)sIn.GetBuffer(nLen);
	BYTE b = 0;
	
	//alloc out buffer
	pOutBuf = (LPBYTE)sOut.GetBuffer(nLen  * 3 - 2); //new BYTE [nLen  * 3];

	if ( pOutBuf ) {
		pInTmp	= pInBuf;
		pOutTmp = pOutBuf;
		// do encoding - 强制编码所有字符 xxli@2004.09.16
		while (*pInTmp) {
			//if ( isalnum(*pInTmp) ) {
			//	*pOutTmp++ = *pInTmp;
			//} else if ( isspace(*pInTmp) ) {
			//		*pOutTmp++ = '+';
			//} else {
				*pOutTmp++ = '%';
				*pOutTmp++ = toHex(*pInTmp>>4);
				*pOutTmp++ = toHex(*pInTmp%16);
			//}
			pInTmp++;
		}
		*pOutTmp = '\0';
		sOut.ReleaseBuffer();
	}
	sIn.ReleaseBuffer();
	return sOut;
}
*/