TEMP

#include "stdafx.h"
#include "MqCallBack.h"
#include "SLabelTrayDlg.h"

#include "../common/LocalCfg.h"

#include "../SLabelMQ/SLabelMQLib.h"

#include "../SLabelGui/SLabelGuiLib.h"



#include <boost/format.hpp>

#include <stdarg.h>
#include <assert.h>

//调试业务流程
#ifdef DEBUG
#define TRACE_CMD(cmd, type) traceCmd(cmd, type)
#else
#define TRACE_CMD(cmd, type)
#endif

CMqCallBack::CMqCallBack(CSLabelTrayDlg* pTrayDlg)
	:m_pTrayDlg(pTrayDlg)
{
	initMsgMap();
}


CMqCallBack::~CMqCallBack(void)
{
	_msgMap.clear();
}

void CMqCallBack::insert(int cmd, std::wstring header, std::wstring format, ...)
{
	std::wstring end(L"\0");

	std::vector<std::wstring> content;
	content.push_back(header);
	content.push_back(format);
	va_list ap;
	va_start(ap, format);
	std::wstring str;
	while(true)
	{
		str = va_arg(ap, std::wstring);
		if (str == end)
		{
			break;
		}
		content.push_back(str);
	}
	va_end(ap);

#ifdef DEBUG
	//test invalid cmd
	std::map<int, std::vector<std::wstring>>::const_iterator iter;
	iter = _msgMap.find(cmd);
	assert(iter == _msgMap.end());
#endif

	_msgMap[cmd] = content;
}


void CMqCallBack::initMsgMap()
{
	using namespace SLabel::Model;

	std::wstring filename(L"filename");
	std::wstring user(L"user");
	std::wstring fileid(L"fileid");
	std::wstring depart(L"depart");
	std::wstring submituser(L"submituser");
	std::wstring audituser(L"audituser");
	std::wstring resultdecribed(L"resultdecribed");
	std::wstring message(L"message");

	std::wstring end(L"\0");

	insert(Fix, L"您收到一个定密申请任务",
		L"申请部门：%s\r\n申请人员：%s\r\n申请文件：%s", depart, user, filename, end);
	insert(CheckFixResult | Pass | AuditYes,L"您的定密申请已审核通过", 
		L"申请文件：%s\r\n申请状态：%s 审核通过，已转交给 %s 确认\r\n审核意见：%s",  filename, submituser, audituser, resultdecribed, end);
	insert(CheckFixResult | Pass | AuditNo, L"您的定密申请已审批通过", 
		L"申请文件：%s\r\n申请状态：%s 审批通过\r\n审批意见：%s", filename , submituser , resultdecribed, end);
	insert(CheckFixResult | Reject, L"您的定密申请被驳回",
		L"申请文件：%s\r\n申请状态：%s 未通过，申请被驳回\r\n审核意见：%s", filename , submituser , resultdecribed, end);
	insert(NotifyKnowUser, L"您收到一个共享文档", 
		L"您有一个文件共享通知：\r\n文件名称：%s \r\n文件作者：%s", filename , user, end);
	insert(NotifyMiddleUser | Pass | AuditNo, 
		L"您审核的文件已审批通过", L"申请文件：%s\r\n申请状态：%s 审批通过\r\n审批意见：%s", filename , submituser , resultdecribed, end);
	insert(NotifyMiddleUser | Reject, L"您审核的一个文件被驳回", 
		L"申请文件：%s\r\n申请状态：%s 未通过，申请被驳回\r\n审核意见：%s", filename , submituser , resultdecribed, end);
	insert(RequestChangeApply, L"您收到一个变更申请任务",
		L"申请部门：%s\r\n申请人员：%s\r\n申请文件：%s", depart , user , filename, end);
	insert(ChangeApplyNotifyOriUser | Pass | AuditYes, L"您的变更申请已完成审核", 
		L"变更文件：%s\r\n变更状态：%s 审核通过，已转交给 %s 确认\r\n审核意见：%s", filename , submituser , audituser , resultdecribed, end);
	insert(ChangeApplyNotifyOriUser | Pass | AuditNo, L"您的变更申请已审批通过", 
		L"变更文件：%s\r\n变更状态：%s 审批通过\r\n审批意见：%s", filename , submituser , resultdecribed, end);
	insert(ChangeApplyNotifyOriUser | Reject, L"您的变更申请被驳回", 
		L"变更文件：%s\r\n变更状态：%s 未通过，申请被驳回\r\n审核意见：%s", filename , submituser , resultdecribed, end);
	insert(ChangeApplyNotifyMiddleUser | Pass | AuditYes, L"变更状态通知", 
		L"变更文件：%s\r\n变更状态：%s 审核通过，已转交给 %s 确认\r\n审核意见：%s", filename , submituser , audituser , resultdecribed, end);
	insert(ChangeApplyNotifyMiddleUser | Pass | AuditNo, L"您审核的变更申请通过审批", 
		L"变更文件：%s\r\n变更状态：%s 审批通过\r\n审批意见：%s", filename , submituser , resultdecribed, end);
	insert(ChangeApplyNotifyMiddleUser | Reject, L"您审核的变更申请被驳回", 
		L"变更文件：%s\r\n变更状态：%s 未通过，申请被驳回\r\n审核意见：%s", filename , submituser , resultdecribed, end);
	insert(ChangeApplyNotifyKnowers, L"您收到一个变更后的共享文档", 
		L"您有一个文件共享通知：\r\n文件名称：%s \r\n文件作者：%s",filename , user, end);
	insert(RequestDecrypt, L"您收到一个解密申请",
		L"申请部门：%s\r\n申请人员：%s\r\n申请文件：%s", depart, user, filename, end);
	insert(DecryptNotifyOriUser | Pass | AuditYes, L"您的解密申请已通过审核", 
		L"解密文件：%s\r\n解密状态：%s 审核通过，已转交给 %s 确认\r\n审核意见：%s", filename , submituser , audituser , resultdecribed, end);
	insert(DecryptNotifyOriUser | Pass | AuditNo, L"您的解密申请已审批通过", 
		L"解密文件：%s\r\n解密状态：%s 审批通过\r\n审批意见：%s", filename , submituser , resultdecribed, end);
	insert(DecryptNotifyOriUser | Reject, L"您的解密申请未通过", 
		L"解密文件：%s\r\n解密状态：%s 未通过，申请被驳回\r\n审核意见：%s", filename , submituser , resultdecribed, end);
	insert(DecryptNotifyMiddleUser | Pass | AuditYes, L"解密状态通知",
		L"解密文件：%s\r\n解密状态：%s 审核通过，已转交给 %s 确认\r\n审核意见：%s", filename , submituser , audituser , resultdecribed, end);
	insert(DecryptNotifyMiddleUser | Pass | AuditNo, L"您审核的解密文件审批通过", 
		L"解密文件：%s\r\n解密状态：%s 审批通过\r\n审批意见：%s", filename , submituser , resultdecribed, end);
	insert(DecryptNotifyMiddleUser | Reject, L"您审核的解密文件被驳回", 
		L"解密文件：%s\r\n解密状态：%s 未通过，申请被驳回\r\n审核意见：%s", filename , submituser , resultdecribed, end);
	insert(DecryptNotifyKnowers, L"您收到一个共享的解密文件", 
		L"您有一个文件共享通知：\r\n文件名称：%s \r\n文件作者：%s", filename , user, end);
	insert(RequestRemoveSlabel, L"您收到一个解除标志申请任务", 
		L"申请部门：%s\r\n申请人员：%s\r\n解除标志文件：%s", depart , user , filename, end);
	insert(RemoveSlabelNotifyOriUser | Pass | AuditYes, L"您的解除标志申请已完成审核", 
		L"解除标志文件：%s\r\n解除标志状态：%s 审核通过，已转交给 %s 确认\r\n审核意见：%s", filename , submituser , audituser , resultdecribed, end);
	insert(RemoveSlabelNotifyOriUser | Pass | AuditNo, L"您的解除标志申请已审批通过", 
		L"解除标志文件：%s\r\n解除标志状态：%s 审批通过\r\n审批意见：%s", filename , submituser , resultdecribed, end);
	insert(RemoveSlabelNotifyOriUser | Reject, L"您的解除标志申请被驳回", 
		L"解除标志文件：%s\r\n解除标志状态：%s 未通过，申请被驳回\r\n审核意见：%s", filename , submituser , resultdecribed, end);
	insert(RemoveSlabelNotifyKnowers, L"您收到一个解除标志的共享通知", 
		L"您有一个解除标志共享通知：\r\n文件名称：%s \r\n文件作者：%s", filename , user, end);
	insert(RequestPrint, L"您收到一个打印申请任务", 
		L"申请部门：%s\r\n申请人员：%s\r\n申请文件：%s", depart , user , filename, end);
	insert(PrintNotifyOriUser | Pass | AuditYes, L"您的打印申请已完成审核", 
		L"打印文件：%s\r\n申请状态：%s 审核通过，已转交给 %s 确认\r\n审核意见：%s",filename , submituser , audituser , resultdecribed, end);
	insert(PrintNotifyOriUser | Pass | AuditNo, L"您的打印申请已审批通过", 
		L"打印文件：%s\r\n申请状态：%s 审批通过\r\n审批意见：%s", filename , submituser , resultdecribed, end);
	insert(PrintNotifyOriUser | Reject, L"您的打印申请被驳回", 
		L"打印文件：%s\r\n申请状态：%s 未通过，申请被驳回\r\n审批意见：%s", filename , submituser , resultdecribed, end);
	insert(RequestOut, L"您收到一个文件外发申请任务",
		L"申请部门：%s\r\n申请人员：%s\r\n申请文件：%s", depart , user , filename, end);
	insert(OutNotifyOriUser | Pass | AuditYes, L"您的文件外发申请已完成审核",
		L"外发文件：%s\r\n申请状态：%s 审核通过，已转交给 %s 确认\r\n审核意见：%s", filename , submituser , audituser , resultdecribed, end);
	insert(OutNotifyOriUser | Pass | AuditNo, L"您的文件外发申请已审批通过", 
		L"外发文件：%s\r\n申请状态：%s 审批通过\r\n审批意见：%s", filename , submituser , resultdecribed, end);
	insert(OutNotifyOriUser | Reject, L"您的文件外发申请被驳回", 
		L"外发文件：%s\r\n申请状态：%s 未通过，申请被驳回\r\n审批意见：%s", filename , submituser , resultdecribed, end);
	insert(CancelTask, L"您的定密申请已撤销",
		L"文件名称：%s \r\n文件作者：%s", filename , user, end);
	insert(CancelPrintlTask, L"您的打印申请已撤销", 
		L"文件名称：%s \r\n文件作者：%s", filename , user, end);
	insert(CancelOutTask, L"您的外发申请已撤销", 
		L"文件名称：%s \r\n文件作者：%s", filename , user, end);
	insert(ErrorInfo, L"系统消息",
		L"%s", message, end);
}


void CMqCallBack::getMsgByCmd(std::wstring& header, std::wstring& content, int cmd, MqJsonPtr spMqJson)
{
	header.clear();
	content.clear();

	std::map<int, std::vector<std::wstring>>::const_iterator iter;
	iter = _msgMap.find(cmd);
	if (iter != _msgMap.end())
	{
		std::vector<std::wstring> msg = iter->second;
		formatContent(header, content, msg, spMqJson);
	}
	else
	{
		assert(false);
	}
}

void CMqCallBack::formatContent(std::wstring& header, std::wstring& content, std::vector<std::wstring>& msg, MqJsonPtr spMqJson)
{
	//must include header and content
	if (msg.size() < 2)
	{
		assert(false);
		return;
	}

	header = msg[0];
	std::wstring fomat = msg[1];
	std::vector<std::wstring> args;
	for (unsigned int i = 2; i < msg.size(); i++)
	{
		std::wstring data;
		getJsonData(data, msg[i], spMqJson);
		args.push_back(data);
	}
	//format
	boost::wformat fmt = boost::wformat(fomat);
	switch(args.size())
	{
	case 0:
		content = fomat;
		break;
	case 1:
		content = (fmt % args[0]).str(); 
		break;
	case 2:
		content = (fmt % args[0] % args[1]).str(); 
		break;
	case 3:
		content = (fmt % args[0] % args[1] % args[2]).str(); 
		break;
	case 4:
		content = (fmt % args[0] % args[1] % args[2] % args[3]).str(); 
		break;
	case 5:
		content = (fmt % args[0] % args[1] % args[2] % args[3] % args[4]).str(); 
		break;
	case 6:
		content = (fmt % args[0] % args[1] % args[2] % args[3] % args[4] % args[5]).str(); 
		break;
	default:
		assert(false);
	}
}

void CMqCallBack::getJsonData(std::wstring& data, const std::wstring& arg, MqJsonPtr spMqJson)
{
	data.clear();

	std::wstring filename(L"filename");
	std::wstring user(L"user");
	std::wstring fileid(L"fileid");
	std::wstring depart(L"depart");
	std::wstring submituser(L"submituser");
	std::wstring audituser(L"audituser");
	std::wstring resultdecribed(L"resultdecribed");
	std::wstring message(L"message");

	if (arg == filename)
	{
		spMqJson->GetString(filename, data);
	}
	else if (arg == user)
	{
		spMqJson->GetString(user, data);
	}
	else if (arg == fileid)
	{
		spMqJson->GetString(fileid, data);
	}
	else if (arg == depart)
	{
		spMqJson->GetString(depart, data);
	}
	else if (arg == submituser)
	{
		spMqJson->GetString(submituser, data);
	}
	else if (arg == audituser)
	{
		spMqJson->GetString(audituser, data);
	}
	else if (arg == resultdecribed)
	{
		boost::shared_ptr<SLabel::Model::MqJsonFix>spFix = boost::dynamic_pointer_cast<SLabel::Model::MqJsonFix>(spMqJson);  
		shared_array<AuditHistory> ptrHistory;
		if(ptrHistory)
		{
			ptrHistory.reset();
		}
		int count;
		spFix->ParseFixHistory(ptrHistory, count);
		if (!ptrHistory || count < 2)
		{
			assert(false);
		}
		data = ptrHistory[1].resultdecribed;
	}
	else if (arg == message)
	{
		spMqJson->GetString(message, data);
	}
	else
	{
		assert(false);
	}
}

bool CMqCallBack::histroyResult(MqJsonPtr spMqJson)
{
	boost::shared_ptr<SLabel::Model::MqJsonFix>spFix = boost::dynamic_pointer_cast<SLabel::Model::MqJsonFix>(spMqJson);  
	shared_array<AuditHistory> ptrHistory;
	if(ptrHistory)
	{
		ptrHistory.reset();
	}
	int count;
	spFix->ParseFixHistory(ptrHistory, count);
	if (!ptrHistory || count < 2)
	{
		assert(false);
	}
	return (ptrHistory[1].result == 1);
}

bool CMqCallBack::hasAuditUser(MqJsonPtr spMqJson)
{
	std::wstring audituser;
	spMqJson->GetString(L"audituser",audituser);
	return !audituser.empty();
}

void CMqCallBack::addPoupeMessage(int cmd, 
	MqJsonPtr spMqJson)
{
	std::wstring header, content;
	getMsgByCmd(header, content, cmd, spMqJson);
	m_pTrayDlg->m_poupeWnd.AddMessage(header,content);
}

void CMqCallBack::addPoupeMessage(int cmd, 
	MqJsonPtr spMqJson,
	bool isLinker,
	std::wstring url,
	std::wstring data,
	int type)
{
	std::wstring header, content;
	getMsgByCmd(header, content, cmd, spMqJson);
	std::wstring fileid;
	spMqJson->GetString(L"fileid", fileid);
	m_pTrayDlg->m_poupeWnd.AddMessage(header,content,isLinker,url,data, fileid, type);
}

void CMqCallBack::showPoupeWnd()
{
	m_pTrayDlg->m_poupeWnd.ShowFirst();
}

void CMqCallBack::updateTrayIconTip(int connectStatu )
{
	m_pTrayDlg->m_connectStatu = connectStatu;
	m_pTrayDlg->UpdateTrayIcon();   
}

void CMqCallBack::mqSend(std::wstring text)
{
	std::string ssText = CTChar::ws2s(text);
	int result = MqSend((void*)ssText.c_str(), ssText.length() + 1);
	if (result)
	{
		OutputDebugStringA("[CMqCallBack] Send Mq Data Error!");
		assert(false);
	}
#ifdef DEBUG
	//回调Mq的CMD可以检测到，但是发送Mq的CMD有的是在对话框里面发送的
	//有的是在外面发送的
	using namespace SLabel::Model;
	boost::shared_ptr<MqJson>spMqJson = MqJsonFactory::MakeMqJson(text);       
	if (!spMqJson.get())
	{
		return;
	}
	int cmd = spMqJson->GetCmd();
	TRACE_CMD(cmd, 1);
#endif
}

void CMqCallBack::traceCmd(int cmd, int type)
{
	using namespace SLabel::Model;
	string strCmd;
	switch(cmd)
	{
	case Fix: strCmd = "Fix"; break;
	case CheckFix: strCmd = "CheckFix"; break;
	case CheckFixResult: strCmd = "CheckFixResult"; break;
	case NotifyKnowUser: strCmd = "NotifyKnowUser"; break;
	case NotifyMiddleUser: strCmd = "NotifyMiddleUser"; break;
	case TaskManage: strCmd = "TaskManage"; break;
	case ErrorInfo: strCmd = "ErrorInfo"; break;
	case UserRequest: strCmd = "UserRequest"; break;
	case CompanyDepartRequest: strCmd = "CompanyDepartRequest"; break;
	case FixBasis: strCmd = "FixBasis"; break;
	case FileCheck: strCmd = "FileCheck"; break;
	case RequestChangeApply: strCmd = "RequestChangeApply"; break;
	case ChangeApplyNotifyOriUser: strCmd = "ChangeApplyNotifyOriUser"; break;
	case ChangeApplyNotifyKnowers: strCmd = "ChangeApplyNotifyKnowers"; break;
	case ChangeApplyNotifyMiddleUser: strCmd = "ChangeApplyNotifyMiddleUser"; break;
	case RequestDecrypt: strCmd = "RequestDecrypt"; break;
	case DecryptNotifyOriUser: strCmd = "DecryptNotifyOriUser";break;
	case DecryptNotifyKnowers: strCmd = "DecryptNotifyKnowers"; break;
	case DecryptNotifyMiddleUser: strCmd = "DecryptNotifyMiddleUser"; break;
	case RequestRemoveSlabel: strCmd = "RequestRemoveSlabel"; break;
	case RemoveSlabelNotifyOriUser: strCmd = "RemoveSlabelNotifyOriUser"; break;
	case RemoveSlabelNotifyKnowers: strCmd = "RemoveSlabelNotifyKnowers"; break;
	case RemoveSlabelNotifyMiddleUser: strCmd = "RemoveSlabelNotifyMiddleUser"; break;
	case RequestPrint: strCmd = "RequestPrint"; break;
	case PrintNotifyOriUser: strCmd = "PrintNotifyOriUser"; break;        
	case RequestOut: strCmd = "RequestOut"; break;
	case OutNotifyOriUser: strCmd = "OutNotifyOriUser"; break;
	case CancelTask: strCmd = "CancelTask"; break;
	case CancelPrintlTask: strCmd = "CancelPrintlTask"; break;
	case CancelOutTask: strCmd = "CancelOutTask"; break;
	case DecryptTip: strCmd = "DecryptTip"; break;
	case ResponseOperation: strCmd = "ResponseOperation"; break;
	case None: strCmd = "None"; break;
	default: strCmd = "Error"; break;
	};
	char outDebug[100] = {0};
	if (type == 0)
		sprintf_s(outDebug, 100, "MqReceive===%s", strCmd.c_str());
	else
		sprintf_s(outDebug, 100, "MqSend=====%s", strCmd.c_str());
	OutputDebugStringA(outDebug);
}

void CMqCallBack::checkFixImp(const std::wstring& data, MqJsonPtr spMqJson)
{
	using namespace SLabel::Model;

	wstring strFileName,strApply,strFileID,strAuditer;
	spMqJson->GetString(L"filename",strFileName);
	spMqJson->GetString(L"user",strApply);
	spMqJson->GetString(L"fileid",strFileID);
	spMqJson->GetString(L"audituser",strAuditer);
	int taskType(-1);
	spMqJson->GetInt(L"tasktype", taskType);

	wstring taskid;
	spMqJson->GetString(L"taskid",taskid);

	std::auto_ptr<SHOW_MESSAGE> apMessage(new SHOW_MESSAGE);
	apMessage->caption = L"定密申请";
	apMessage->AddItem(L"申请文件:",strFileName,true,L"",data, strFileID);

	int taskstatus = TaskStatu_Apply;
	spMqJson->GetInt(L"taskstatus", taskstatus);
	// 任务被拒绝
	if (taskstatus == TaskStatu_Reject)
	{
		int tasktype;
		spMqJson->GetInt(L"tasktype", tasktype);
		switch (tasktype)
		{                
		case TaskType_PrintCtrl:
			{
				wstring text;   
				if (PrintCtrlApplyDialog(data, text) == IDOK)
					mqSend(text);
			}
			break;
		case TaskType_OutCtrl:
			{
				wstring text;   
				if (OutCtrlApplyDialog(data, text) == IDOK)
					mqSend(text);
			}
			break;
		default:
			{
				ShowDealRejestWnd(data);
			}
			break;
		} 

		// 如果是任务被拒绝，下面解析不对，不用处理
		return;
	}

	int optType(-1);
	spMqJson->GetInt(L"opt_type", optType);
	// 0-9，表示处理申请，optType表示任务类型
	if (optType > -1 && optType < 10) 
	{
		// 此时optType作为taskType，taskType不一定正确
		switch (optType)
		{
		case TaskType_Fix:
			break;
		case TaskType_Change:
			{
				wstring text;
				wstring newData = getRightData(spMqJson);
				ChangeApplyDialog(newData, text);
			}
			break;
		case TaskType_Decrypt:
			{
				wstring text;
				wstring newData = getRightData(spMqJson);
				if (DecryptApplyDialog(newData, text) == IDOK)
					mqSend(text);
			}
			break;
		case TaskType_RemoveSlabel:
			{
				wstring text;   
				if (RemoveSlabelApplyDialog(data, text) == IDOK)
					mqSend(text);
			}
			break;
		case TaskType_PrintCtrl:
			{
				wstring text;   
				if (PrintCtrlApplyDialog(data, text) == IDOK)
					mqSend(text);
			}
			break;
		case TaskType_OutCtrl:
			{
				wstring text;   
				if (OutCtrlApplyDialog(data, text) == IDOK)
					mqSend(text);
			}
			break;
		}  
	}   
	// 撤销申请
	else if (optType == 21) 
	{   
		SLabel::Model::MqJsonTask json; 
		int result = json.MakeCancelTask(m_pTrayDlg->m_user.username,m_pTrayDlg->m_user.userid, taskid);
		if (result == S_OK)
		{
			wstring text;
			json.ToString(text);
			mqSend(text);

			Sleep(500);
			SendCopyDataMessage(0);
		}     
	}
	// 10-19，表示处理审核
	else //if (optType > 10) 
	{
		switch (taskType)
		{
		case TaskType_Fix:        
			m_pTrayDlg->ShowCheckDlg(apMessage->items[0].get());                       
			break;
		case TaskType_Change:
			{
				wstring text;
				if (ChangeDialog(data, text) == IDOK)
					mqSend(text);


			}
			break;
		case TaskType_Decrypt:
			{
				wstring text;
				if (DecryptDialog(data, text) == IDOK)
					mqSend(text);
			}
			break;
		case TaskType_RemoveSlabel:
			{
				wstring text;
				if (RemoveSlabelDialog(data, text) == IDOK)
					mqSend(text);
			}
			break;
		case TaskType_PrintCtrl:
			{
				wstring text;   
				if (PrintCtrlDialog(data, text) == IDOK)
					mqSend(text);
			}
			break;
		case TaskType_OutCtrl:
			{
				wstring text;   
				if (OutCtrlDialog(data, text) == IDOK)
					mqSend(text);
			}
			break;
		}
	}
}

std::wstring CMqCallBack::getRightData(MqJsonPtr spMqJson)
{
	using namespace SLabel::Model;
	wstring filename,strFileID;
	spMqJson->GetString(L"fileid",strFileID);
	std::map<std::wstring,std::wstring>::iterator i= m_pTrayDlg->m_mapFilenames.find(strFileID);
	if(i != m_pTrayDlg->m_mapFilenames.end())
	{
		spMqJson->SetString(L"filename",i->second);
		m_pTrayDlg->m_mapFilenames.erase(i);
	}

	wstring data;
	spMqJson->ToString(data);
	return data;
}

void CMqCallBack::Connect( const std::wstring& data )
{
	int nTimeInterval = CLocalCfg::get_const_instance().GetTimeInterval();

	// mq连接失败
	if(data.empty())
	{
		if (m_pTrayDlg->m_isConnected == false && m_pTrayDlg->m_connectStatu == UNCONNECTED)
		{
			return;
		}

		m_pTrayDlg->m_isConnected = false;
		m_pTrayDlg->m_connectStatu = UNCONNECTED;
		m_pTrayDlg->UpdateTrayIcon();  

		m_pTrayDlg->SetTimer(TIMER_TRY_CONNECT, nTimeInterval * 1000, NULL);

		return ;
	}   

	// mq需要二个连接，一个发送，一个接收
	// 这里指其中一个连接完成，还需要第二个连接
	if (data == L"SLabelServer:1")
	{
		m_pTrayDlg->m_connectStatu = CONNECTING;
		RegeditMqUser(m_pTrayDlg->m_user.userid);
	}
	// mq连接成功
	else if (data == L"SLabelServer:2")
	{
		m_pTrayDlg->m_connectStatu = CONNECTED;
		m_pTrayDlg->UpdateTrayIcon();

		// 请求组织机构，定密依据等
		// 此函数名比较老，作为心跳包，请求组织机构、定密依据是否有更新等
		m_pTrayDlg->UserRegister();

		// 启动心跳包定时器
		m_pTrayDlg->SetTimer(TIMER_USER_REGISTER, nTimeInterval * 1000, NULL);

		//不懂
		HWND hWnd1 = ::FindWindowA(NULL, string(BROWER_TITLE_NAME + CLocalCfg::get_const_instance().GetVersion()).c_str());
		if(hWnd1)
		{
			::PostMessage(hWnd1, WM_CANCELJOURNAL, NULL, NULL);
		}
	}  
}

void CMqCallBack::Receive( const std::wstring& data )
{
	using namespace SLabel::Model;

	m_pTrayDlg->m_isConnected = true;

	// 把mq解析成实际业务的json对象
	boost::shared_ptr<MqJson>spMqJson = MqJsonFactory::MakeMqJson(data);       
	if (!spMqJson.get())
	{
		return;
	}

	// 每一个cmd代表一个业务，具体参考详细设计文档
	int cmd = spMqJson->GetCmd();

	TRACE_CMD(cmd, 0);

	switch (cmd)
	{
	case ResponseOperation:
		{
			SendCopyDataMessage(4);
		}
		break;
	case CheckFix:
		{
			updateTrayIconTip(CONNECTED);
			checkFixImp(data, spMqJson);
		}
		break;
	case Fix:
		{
			addPoupeMessage(Fix, spMqJson, true,L"",data, ID_SHOW_CHECK_DLG);
			showPoupeWnd();
			updateTrayIconTip(TIP);
		}
		break;
	case CheckFixResult:
		{
			if(histroyResult(spMqJson))  //pass
			{
				if (hasAuditUser(spMqJson))//AuditYes
				{
					addPoupeMessage(CheckFixResult | Pass | AuditYes, spMqJson);
				}
				else //AuditNo
				{
					addPoupeMessage(CheckFixResult | Pass | AuditNo, spMqJson);

					SendCopyDataMessage(2);
				}
			}
			else //Reject
			{
				addPoupeMessage(CheckFixResult | Reject, spMqJson, true, L"", data, ID_SEND_REJEST);
			}
			showPoupeWnd();
		}           
		break;
	case CompanyDepartRequest:
		{
			boost::shared_ptr<MqJsonUserInfo>spUsers = boost::dynamic_pointer_cast<MqJsonUserInfo>(spMqJson);  
			wstring out;
			spUsers->ToString(out);
			m_pTrayDlg->SaveCompanyInfo(spUsers);

			int version;
			spMqJson->GetInt(L"secret_version", version);
			if (m_pTrayDlg->m_fixBasisVersion < version)
			{
				m_pTrayDlg->CheckFixBasis();
			}
		}
		break;
	case ErrorInfo:
		{
			// 有些应该弹出窗口的，因为错误，弹出poupe窗口错误提示，但是qt浏览器锁住了
			// 强制解锁
			SendCopyDataMessage(NULL);

			addPoupeMessage(ErrorInfo, spMqJson);
			showPoupeWnd();
		}
		break;
	case TaskManage:    
		{ 

		}
		break;
	case FixBasis:
		{
			boost::shared_ptr<MqJsonFixBasis>spUsers = boost::dynamic_pointer_cast<MqJsonFixBasis>(spMqJson);  
			m_pTrayDlg->UpdateFixBasis(spUsers.get());
		}
		break;
	case FileCheck:
		{
			boost::shared_ptr<MqJsonFileCheck>spUsers = boost::dynamic_pointer_cast<MqJsonFileCheck>(spMqJson);
			SetFileCheckResult(spUsers);
		}
		break;
	case NotifyKnowUser:
		{
			addPoupeMessage(NotifyKnowUser, spMqJson);
			showPoupeWnd();
		}
		break;
	case NotifyMiddleUser:
		{
			if(histroyResult(spMqJson))  //pass
			{
				if (hasAuditUser(spMqJson))//AuditYes
				{
					assert(false);
				}
				else //AuditNo
				{
					addPoupeMessage(NotifyMiddleUser | Pass | AuditNo, spMqJson);

					SendCopyDataMessage(2);
				}
			}
			else //Reject
			{
				addPoupeMessage(NotifyMiddleUser | Reject, spMqJson);
			}
			showPoupeWnd();
		}
		break;
	case RequestChangeApply:
		{              
			addPoupeMessage(RequestChangeApply, spMqJson, true, L"", data, ID_SHOW_CHANGE_DLG);
			showPoupeWnd();
			updateTrayIconTip(TIP);                                     		
		}
		break;
	case ChangeApplyNotifyOriUser:
		{
			if(histroyResult(spMqJson))  //pass
			{
				if (hasAuditUser(spMqJson))//AuditYes
				{
					addPoupeMessage(ChangeApplyNotifyOriUser | Pass | AuditYes, spMqJson);
				}
				else //AuditNo
				{
					addPoupeMessage(ChangeApplyNotifyOriUser | Pass | AuditNo, spMqJson);

					SendCopyDataMessage(2);
				}
			}
			else //Reject
			{
				addPoupeMessage(ChangeApplyNotifyOriUser | Reject, spMqJson, true, L"", data, ID_SEND_REJEST);
			}
			showPoupeWnd();
		}
		break;
	case ChangeApplyNotifyMiddleUser:
		{
			if(histroyResult(spMqJson))  //pass
			{
				if (hasAuditUser(spMqJson))//AuditYes
				{
					addPoupeMessage(ChangeApplyNotifyMiddleUser | Pass | AuditYes, spMqJson);
				}
				else //AuditNo
				{
					addPoupeMessage(ChangeApplyNotifyMiddleUser | Pass | AuditNo, spMqJson);

					SendCopyDataMessage(2);
				}
			}
			else //Reject
			{
				addPoupeMessage(ChangeApplyNotifyMiddleUser | Reject, spMqJson);
			}
			showPoupeWnd();
		}
		break;
	case ChangeApplyNotifyKnowers:
		{
			addPoupeMessage(ChangeApplyNotifyKnowers, spMqJson);
			showPoupeWnd();
		}
		break;
		
	case RequestDecrypt:
		{
			addPoupeMessage(RequestDecrypt, spMqJson, true,L"",data, ID_SHOW_DECRYPT_DLG);
			showPoupeWnd();  
			updateTrayIconTip(TIP);
		}
		break;
	case DecryptNotifyOriUser:
		{
			if(histroyResult(spMqJson))  //pass
			{
				if (hasAuditUser(spMqJson))//AuditYes
				{
					addPoupeMessage(DecryptNotifyOriUser | Pass | AuditYes, spMqJson);
				}
				else //AuditNo
				{
					addPoupeMessage(DecryptNotifyOriUser | Pass | AuditNo, spMqJson);

					SendCopyDataMessage(2);
				}
			}
			else //Reject
			{
				addPoupeMessage(DecryptNotifyOriUser | Reject, spMqJson, true, L"", data, ID_SEND_REJEST);
			}
			showPoupeWnd();
		}
		break;
	case DecryptNotifyMiddleUser:
		{
			if(histroyResult(spMqJson))  //pass
			{
				if (hasAuditUser(spMqJson))//AuditYes
				{
					addPoupeMessage(DecryptNotifyMiddleUser | Pass | AuditYes, spMqJson);
				}
				else //AuditNo
				{
					addPoupeMessage(DecryptNotifyMiddleUser | Pass | AuditNo, spMqJson);

					SendCopyDataMessage(2);
				}
			}
			else //Reject
			{
				addPoupeMessage(DecryptNotifyMiddleUser | Reject, spMqJson);
			}
			showPoupeWnd();
		}
		break;
	case DecryptNotifyKnowers:
		{
			addPoupeMessage(DecryptNotifyKnowers, spMqJson);
			showPoupeWnd();
		}
		break;
	case RequestRemoveSlabel:
		{              
			addPoupeMessage(RequestRemoveSlabel, spMqJson, true,L"",data, ID_SHOW_REMOVE_SLABEL_DLG);
			showPoupeWnd();
			updateTrayIconTip(TIP);
		}
		break;
	case RemoveSlabelNotifyOriUser:
		{
			if(histroyResult(spMqJson))  //pass
			{
				if (hasAuditUser(spMqJson))//AuditYes
				{
					addPoupeMessage(RemoveSlabelNotifyOriUser | Pass | AuditYes, spMqJson);
				}
				else //AuditNo
				{
					addPoupeMessage(RemoveSlabelNotifyOriUser | Pass | AuditNo, spMqJson);

					SendCopyDataMessage(2);
				}
			}
			else //Reject
			{
				addPoupeMessage(RemoveSlabelNotifyOriUser | Reject, spMqJson, true, L"", data, ID_SEND_REJEST);
			}
			showPoupeWnd();
		}
		break;
	case RemoveSlabelNotifyMiddleUser:
		{
			if(histroyResult(spMqJson))  //pass
			{
				if (hasAuditUser(spMqJson))//AuditYes
				{
					addPoupeMessage(RemoveSlabelNotifyMiddleUser | Pass | AuditYes, spMqJson);
				}
				else //AuditNo
				{
					addPoupeMessage(RemoveSlabelNotifyMiddleUser | Pass | AuditNo, spMqJson);

					SendCopyDataMessage(2);
				}
			}
			else //Reject
			{
				addPoupeMessage(RemoveSlabelNotifyMiddleUser | Reject, spMqJson);
			}
			showPoupeWnd();
		}
		break;
	case RemoveSlabelNotifyKnowers:
		{
			addPoupeMessage(RemoveSlabelNotifyKnowers, spMqJson);
			showPoupeWnd();
		}
		break;

	case RequestPrint:
		{              
			addPoupeMessage(RequestPrint, spMqJson, true,L"",data, ID_SHOW_CHANGE_DLG);
			showPoupeWnd();
			updateTrayIconTip(TIP);
		}
		break;
	case PrintNotifyOriUser:
		{
			if(histroyResult(spMqJson))  //pass
			{
				if (hasAuditUser(spMqJson))//AuditYes
				{
					addPoupeMessage(PrintNotifyOriUser | Pass | AuditYes, spMqJson);
				}
				else //AuditNo
				{
					addPoupeMessage(PrintNotifyOriUser | Pass | AuditNo, spMqJson);

					SendCopyDataMessage(2);
				}
			}
			else //Reject
			{
				addPoupeMessage(PrintNotifyOriUser | Reject, spMqJson, true, L"", data, ID_SEND_REJEST);
			}
			showPoupeWnd();
		}
		break;

	case RequestOut:
		{              
			addPoupeMessage(RequestOut, spMqJson, true,L"",data, ID_SHOW_CHANGE_DLG);
			showPoupeWnd();
			updateTrayIconTip(TIP);                                  		
		}
		break;
	case OutNotifyOriUser:
		{
			if(histroyResult(spMqJson))  //pass
			{
				if (hasAuditUser(spMqJson))//AuditYes
				{
					addPoupeMessage(OutNotifyOriUser | Pass | AuditYes, spMqJson);
				}
				else //AuditNo
				{
					addPoupeMessage(OutNotifyOriUser | Pass | AuditNo, spMqJson);

					SendCopyDataMessage(2);
				}
			}
			else //Reject
			{
				addPoupeMessage(PrintNotifyOriUser | Reject, spMqJson, true, L"", data, ID_SEND_REJEST);
			}
			showPoupeWnd();
		}
		break;

	case CancelTask:
		{       
			addPoupeMessage(CancelTask, spMqJson);
			showPoupeWnd();
		}
		break;
	case CancelPrintlTask:
		{
			addPoupeMessage(CancelPrintlTask, spMqJson);
			showPoupeWnd();
		}
		break;
	case CancelOutTask:
		{
			addPoupeMessage(CancelOutTask, spMqJson);
			showPoupeWnd();
		}
		break;
	case DecryptTip:
		{
			//解密操作里面，没有解密提醒这个消息，故删除之
			assert(false);
		}
		break;
		
	default:
		break;
	}
}