kxmlmanager.cpp

数据安全方面的程序 应用很广泛的 欢迎大家

// KXMLManager.cpp: implementation of the KXMLManager class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "KXMLManager.h"
#include "../KJAlarmProtocol/KAlarmProtocol.h"
#include "../KJAlarmProtocol/KAnswerAlarmProtcol.h"
#include "../KylinSystem/KXMLDocument.h"
#include "../KylinSystem/KXMLNode.h"
#include "../KylinSystem/KPath.h"
#include "../KylinSystem/KLog.h"
#include <vector>
#include <algorithm>
using namespace std;
typedef vector<CString> AlARMINFO;

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
KXMLManager* KXMLManager::_inst = NULL;
CCriticalSection KXMLManager::cs;

KXMLManager::KXMLManager()
{
	
}

KXMLManager::~KXMLManager()
{
	
}

KXMLManager* KXMLManager::Instance()
{
	if(_inst == NULL)
	{
		cs.Lock();
		if(_inst == NULL)
		{
			_inst = new KXMLManager();
		}
		cs.Unlock();
	}
	return _inst;
}

void KXMLManager::Destroy()
{
	delete _inst;
	_inst = NULL;
}

bool KXMLManager::IsHaveStateAlarm(KAlarmProtocol *Alarm)
{
    KXMLDocument  XMLDC;
	XMLDC = GetXMLDocument();
	KXMLNode XMLNODE=XMLDC.GetRootNode();
	
	IXMLDOMNodeListPtr SelectNode=XMLNODE.Select(_T("MessageData[EventID='")+Alarm->GetEventID()+_T("']"));
	if(SelectNode->Getlength() != 0)
	{
		KXMLNode mNode = SelectNode->item[0L];
		KXMLNode StateNode = mNode.GetChild("State");
		if(StateNode.GetValue() == Alarm->Getstate())
		{
			return true;
		}
	}
	return false;
}

void KXMLManager::GetPath(CString FileName)
{
	path=path.GetModuleFile();
	
	path.RemoveFileSpec();
	path.Append(FileName);
	path.RenameExtension();
	
	stPath=path.ToString();
}

void KXMLManager::UpdateXMLInfo(KAlarmProtocol *Alarm)
{
	KXMLDocument  XMLDC;
	XMLDC = GetXMLDocument();
	KXMLNode XMLNODE=XMLDC.GetRootNode();
	
	IXMLDOMNodeListPtr SelectNode=XMLNODE.Select(_T("MessageData[EventID='")+_T(Alarm->GetEventID())+_T("']"));
	if(SelectNode->Getlength()!=0)
	{
		KXMLNode mNode=SelectNode->Getitem(0);

		KGuid mEventID;
		mEventID = mNode.GetChild(_T("EventID")).GetValue();
		NoCeiveAlarmList.erase(mEventID);
		OldAlarmList.erase(mEventID);
		NowAlarmList.erase(mEventID);

		KXMLNode EndTime=mNode.GetChild("EndTime");
		EndTime.SetValue(Alarm->GetEventFinishTime());
		
        KXMLNode State=mNode.GetChild("State");
		State.SetValue(Alarm->Getstate());
		
		KXMLNode MinValue=mNode.GetChild("MinValue");
		MinValue.SetValue(Alarm->GetMinValue());
		
		KXMLNode MaxValue=mNode.GetChild("MaxValue");
		MaxValue.SetValue(Alarm->GetMaxValue());
		
		KXMLNode AverageValue=mNode.GetChild("AverageValue");
		AverageValue.SetValue(Alarm->GetAverageValue());
		
		KXMLNode AlarmingTime=mNode.GetChild("AlarmingTime");
		AlarmingTime.SetValue(Alarm->GetAlarmingTime());
		
		AllAlarm[mEventID] = GetOneAlarmAllInfo(&mNode);
		DispatchEventNode(mNode);
		XMLDC.Save();
	}
	else
	{
        InsertXMLInfo(Alarm);
	}
}

void KXMLManager::InsertXMLInfo(KAlarmProtocol *Alarm)
{
    KXMLDocument  XMLDC;
	XMLDC = GetXMLDocument();
	KXMLNode XMLNODE=XMLDC.GetRootNode();
	
	IXMLDOMNodeListPtr SelectNode=XMLNODE.Select(_T("MessageData[EventID='")+_T(Alarm->GetEventID())+_T("']"));
	if(SelectNode->Getlength()==0)
	{
		KXMLNode NewNode=XMLNODE.AppendChild("MessageData");
		NewNode.AppendChild("EventID",Alarm->GetEventID());
		NewNode.AppendChild("EventType",Alarm->GetEventType());
		NewNode.AppendChild("AlarmMessage",Alarm->GetAlarmMessage());
		NewNode.AppendChild("MineName",Alarm->GetEventMine());
        NewNode.AppendChild("EventMonitorName",Alarm->GetEventMonitorName());
        NewNode.AppendChild("StartTime",Alarm->GetEventBeginTime());
        NewNode.AppendChild("EndTime",Alarm->GetEventFinishTime());
        NewNode.AppendChild("State",Alarm->Getstate());
        NewNode.AppendChild("AlarmName",Alarm->GetAlarmName());
        NewNode.AppendChild("AlarmStyle",Alarm->GetAlarmStyle());
        NewNode.AppendChild("EventLevel",Alarm->GetEventLevel());
        NewNode.AppendChild("UserName",Alarm->GetUseName());
        NewNode.AppendChild("DutyPerson",Alarm->GetDutyPerson());
        NewNode.AppendChild("Tel",Alarm->GetTelephone());
        NewNode.AppendChild("AttemperTel",Alarm->GetAttemperTel());
        NewNode.AppendChild("EventBeginValue",Alarm->GetEventBeginValue());
        NewNode.AppendChild("MinValue",Alarm->GetMinValue());
        NewNode.AppendChild("MaxValue",Alarm->GetMaxValue());
        NewNode.AppendChild("AverageValue",Alarm->GetAverageValue());
        NewNode.AppendChild("AlarmingTime",Alarm->GetAlarmingTime());
        NewNode.AppendChild("IsAnswer","0");
        NewNode.AppendChild("AnswerTime","");
        NewNode.AppendChild("AnswerInfo","");
        NewNode.AppendChild("AnswerPerson","");
        NewNode.AppendChild("IsNoReceiveAlarm",Alarm->GetAlarmType());

		DispatchEventNode(NewNode);
		CString strInfo=GetOneAlarmAllInfo(&NewNode);
		AllAlarm.insert(make_pair(KGuid::Parse(Alarm->GetEventID()), strInfo));
		XMLDC.Save();
	}
}

void KXMLManager::UpdateXMLInfo(KAnswerAlarmProtcol *Answer)
{
    KXMLDocument  XMLDC;
	XMLDC = GetXMLDocument();
	KXMLNode XMLNODE=XMLDC.GetRootNode();
	
	IXMLDOMNodeListPtr SelectNode=XMLNODE.Select(_T("MessageData[EventID='")+_T(Answer->GetEventID())+_T("']"));
	if(SelectNode->Getlength()!=0)
	{
		KXMLNode mNode =SelectNode->Getitem(0);

		KGuid mEventID;
		mEventID = mNode.GetChild(_T("EventID")).GetValue();
		NoCeiveAlarmList.erase(mEventID);
		OldAlarmList.erase(mEventID);
		NowAlarmList.erase(mEventID);
		
		KXMLNode IsAnswer=mNode.GetChild("IsAnswer");
		IsAnswer.SetValue("1");
		
        KXMLNode AnswerTime=mNode.GetChild("AnswerTime");
		AnswerTime.SetValue(Answer->GetAnswerMsgTime());
		
		KXMLNode AnswerInfo=mNode.GetChild("AnswerInfo");
		AnswerInfo.SetValue(Answer->GetAnswerMsg());
		
		AllAlarm[mEventID] = GetOneAlarmAllInfo(&mNode);
		DispatchEventNode(mNode);
		XMLDC.Save();
	}
}

CString KXMLManager::GetAlarmInfo(CString EventID,CString strName)
{
	CString AlarmInfo="";
    KXMLDocument  XMLDC;
	XMLDC = GetXMLDocument();
	KXMLNode XMLNODE=XMLDC.GetRootNode();
	
	IXMLDOMNodeListPtr SelectNode=XMLNODE.Select(_T("MessageData[EventID='")+_T(EventID)+_T("']"));
	if(SelectNode->Getlength()!=0)
	{
		IXMLDOMNodePtr Node=SelectNode->Getitem(0);
		KXMLNode       SelectNode=Node;
		
		KXMLNode MineName=SelectNode.GetChild(strName);
        AlarmInfo=MineName.GetValue();
	}	
	return AlarmInfo;
}

bool KXMLManager::SetXMLInfo(CString EventID, CString stName, CString stValue)
{
    KXMLDocument  XMLDC;
	XMLDC = GetXMLDocument();
	KXMLNode XMLNODE=XMLDC.GetRootNode();

	IXMLDOMNodeListPtr SelectNode=XMLNODE.Select(_T("MessageData[EventID='")+EventID+_T("']"));
	if(SelectNode->Getlength()!=0)
	{
		KXMLNode mNode=SelectNode->Getitem(0);
		KGuid mEventID;
		mEventID = mNode.GetChild(_T("EventID")).GetValue();
		NoCeiveAlarmList.erase(mEventID);
		OldAlarmList.erase(mEventID);
		NowAlarmList.erase(mEventID);

		KXMLNode MineName=mNode.GetChild(stName);
        MineName.SetValue(stValue);
		DispatchEventNode(mNode);
		XMLDC.Save();
		return true;
	}
	return false;
}

void KXMLManager::GetAllAlarm()
{
   	KXMLDocument  XMLDC;
	XMLDC = GetXMLDocument();
	KXMLNode XMLNODE=XMLDC.GetRootNode();

	KGuid mEventID;
	IXMLDOMNodeListPtr AllNode=XMLNODE.Select(_T("MessageData"));
	for(int i=0;i<AllNode->Getlength();i++)
	{
		IXMLDOMNodePtr Node=AllNode->Getitem(i);
		KXMLNode       AlarmNode=Node;

		mEventID = AlarmNode.GetChild(_T("EventID")).GetValue();
		CString strInfo=GetOneAlarmAllInfo(&AlarmNode);
		AllAlarm.insert(make_pair(mEventID, strInfo));
		DispatchEventNode(AlarmNode);
	}
}

CString KXMLManager::GetOneAlarmAllInfo(KXMLNode *Node)
{
	CString stReturn="";
	
	KXMLNode ValueNode=Node->GetChild("EventID");
    stReturn+=ValueNode.GetValue();
	
	ValueNode=Node->GetChild("MineName");
	stReturn+=_T("\t")+ValueNode.GetValue();

	/*
	ValueNode=Node->GetChild("EventType");
	stReturn+=_T("\t")+ValueNode.GetValue();
	
	ValueNode=Node->GetChild("AlarmMessage");
	stReturn+=_T("\t")+ValueNode.GetValue();
	//*/

	ValueNode=Node->GetChild("AlarmName");
	stReturn+=_T("\t")+ValueNode.GetValue();

	ValueNode=Node->GetChild("EventMonitorName");
	stReturn+=_T("\t")+ValueNode.GetValue();

	//ValueNode=Node->GetChild("EventBeginValue");
	//stReturn+=_T("\t")+ValueNode.GetValue();

	ValueNode=Node->GetChild("StartTime");
	stReturn+=_T("\t")+ValueNode.GetValue();

	ValueNode=Node->GetChild("EndTime");
	stReturn+=_T("\t")+ValueNode.GetValue();

	ValueNode = Node->GetChild("StartTime");
	_variant_t var = ValueNode.GetValue();
	var.ChangeType(VT_DATE);
	SYSTEMTIME systime;
	VariantTimeToSystemTime(var.date, &systime);
	CString strTime;
	strTime.Format(_T("%d%02d%02d%02d%02d%02d"), systime.wYear, systime.wMonth, systime.wDay, systime.wHour, systime.wMinute, systime.wSecond);
	stReturn+=_T("\t")+strTime;
	
    return stReturn;
}

void KXMLManager::GetQueryAlarm(CString Query)
{
    KXMLDocument  XMLDC;
	XMLDC = GetXMLDocument();
	KXMLNode XMLNODE=XMLDC.GetRootNode();

	QueryAlarmList.clear();

	KGuid mEventID;
	IXMLDOMNodeListPtr SelectNode=XMLNODE.Select(Query);
	for(int i=0;i<SelectNode->Getlength();i++)
	{
		IXMLDOMNodePtr Node=SelectNode->Getitem(i);
		KXMLNode       AlarmNode=Node;

		mEventID = AlarmNode.GetChild(_T("EventID")).GetValue();
		QueryAlarmList.insert(mEventID);
	}
}

void KXMLManager::SetNoCeiveAlarmState()
{
    KXMLDocument  XMLDC;
	XMLDC = GetXMLDocument();
	KXMLNode XMLNODE=XMLDC.GetRootNode();
    
	IXMLDOMNodeListPtr AllNode=XMLNODE.Select(_T("MessageData[IsNoReceiveAlarm='NOSEND']"));
	for(int i=0;i<AllNode->Getlength();i++)
	{
		IXMLDOMNodePtr Node=AllNode->Getitem(i);
		KXMLNode       AlarmNode=Node;
        
		KXMLNode IsNoReceiveAlarm=AlarmNode.GetChild("IsNoReceiveAlarm");
		IsNoReceiveAlarm.SetValue("");
		DispatchEventNode(AlarmNode);
	}
	NoCeiveAlarmList.clear();
	XMLDC.Save();
}

void KXMLManager::GetQueryAlarm(CString Query, CString FileName, CString FileValue)
{
	KXMLDocument  XMLDC;
	XMLDC = GetXMLDocument();
	KXMLNode XMLNODE=XMLDC.GetRootNode();

	QueryAlarmList.clear();
    
	IXMLDOMNodeListPtr SelectNode=XMLNODE.Select(Query);
	KGuid mEventID;
	for(int i=0;i<SelectNode->Getlength();i++)
	{
		KXMLNode AlarmNode=SelectNode->Getitem(i);
		
		KXMLNode QueryNode=AlarmNode.GetChild(FileName);
		CString  NodeValue=QueryNode.GetValue();
		if(NodeValue.Find(FileValue)!=-1)
		{
			mEventID = AlarmNode.GetChild(_T("EventID")).GetValue();
			QueryAlarmList.insert(mEventID);
		}
	}
}

IXMLDOMDocumentPtr KXMLManager::GetXMLDocument()
{
	if(mEventXml == NULL)
	{
		GetPath("EventInfo");
		KXMLDocument doc;
		doc.Load(path.ToString());
		mEventXml = doc.GetRootNode()->ownerDocument;
	}
	return mEventXml;
}

void KXMLManager::DispatchEventNode(KXMLNode &mEventNode)
{
	KXMLNode State = mEventNode.GetChild("State");
	KXMLNode IsAnswer = mEventNode.GetChild("IsAnswer");
	KXMLNode IsNoReceiveAlarm = mEventNode.GetChild("IsNoReceiveAlarm");
	KGuid mEventID = mEventNode.GetChild(_T("EventID")).GetValue();

	if(IsNoReceiveAlarm.GetValue()=="NOSEND")
	{
		NoCeiveAlarmList.insert(mEventID);
	}
	else if(State.GetValue()=="1" && IsAnswer.GetValue()=="1")
	{
		OldAlarmList.insert(mEventID);
	}
	else
	{
		NowAlarmList.insert(mEventID);
	}
}

void KXMLManager::Clear()
{
	AllAlarm.clear();
	NoCeiveAlarmList.clear();
	NowAlarmList.clear();
	OldAlarmList.clear();
	QueryAlarmList.clear();

	KXMLDocument xml;
	xml.LoadXML(_T("<?xml version=\"1.0\"?>"
		"<NewDataSet/>"));
	xml.Save(path.ToString());
	mEventXml.Release();
}