repos_ecs/Client_1.0.0.5/kernel/VariantManager.cpp

#include "stdafx.h"
#include "kernel.h"
//#include "sharedefine.h"

const char* VARIANT_FILE = "variants.dat";


//---------------------------------------------- VariantsManager ----
CVariantsManager::CVariantsManager()
{
	m_bAnalogAlarm = true;
	m_bIsChangeView = false;
}


CVariantsManager::~CVariantsManager()
{
	int i;
	int nSize = m_analog.GetSize();
	for (i = 0; i < m_analog.GetSize(); i++) 
    {
		CAnalog* analog = m_analog.GetAt(i);

		list<int>::iterator it;
		list<CString>::iterator it_desc;

		for( it = analog->m_listStatusID.begin(); it != analog->m_listStatusID.end(); )
		{
			analog->m_listStatusID.erase( it++ );
		}

		for( it_desc = analog->m_listStatusDesc.begin(); it_desc != analog->m_listStatusDesc.end(); )
		{
			analog->m_listStatusDesc.erase( it_desc++ );
		}

        delete m_analog[i];
    }
	m_analog.RemoveAll();
}

void CVariantsManager::MakeDeviceRelate()
{
	int i, size = m_analog.GetSize();
	if( pDevicesManager == NULL ) return ;
	int nChannelIndex, nChannelSize = pDevicesManager->m_channels.GetSize();
	int nDevicesIndex, nDevicesSize;
	for (i = 0; i < size; i++)
	{
		m_analog.GetAt(i)->m_pDevice = NULL;
		for( nChannelIndex = 0; nChannelIndex < nChannelSize; nChannelIndex++ )
		{
			nDevicesSize = pDevicesManager->m_channels[nChannelIndex]->m_Devices.GetSize();
			for( nDevicesIndex = 0; nDevicesIndex < nDevicesSize; nDevicesIndex++ )
			{
				if( !pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDevicesIndex]->m_strUID.Compare(m_analog.GetAt(i)->m_strVarUID) )
				{
					m_analog.GetAt(i)->m_pDevice = pDevicesManager->m_channels[nChannelIndex]->m_Devices[nDevicesIndex];
				}
			}
		}		
	}
}

void CVariantsManager::Load(char *pStrDirectroy)
{
	CFile file;
	CString fileName = CString(pStrDirectroy) + "\\" + _PROJECTDIR;
	fileName = fileName + VARIANT_FILE;
	if (0 != file.Open( fileName, CFile::modeRead))
	{
		CArchive ar(&file,CArchive::load);
		m_analog.Serialize(ar);
		ar.Close();
		file.Close();

		MakeDeviceRelate();

		//CAnalog *pAnalog = FindAnalogByVarTypeID(SYS_COMMUNCTION_VAR_ID);
		//if( pAnalog == NULL )
		//{
		//	AddSysCommunctionVar();
		//}

		AllocDatePlan();
	}
}
void CVariantsManager::ReadAreaDericeUid( char *pStrDirectroy )
{
	CString sTemp,sPathName;
	CStdioFile File;

	sPathName.Format( "%s\\%sUID.txt",pStrDirectroy,_PROJECTDIR );

	if( !PathFileExists(sPathName) )
		return;
	
	if(!File.Open(sPathName,CFile::modeRead))
		File.Open(sPathName,CFile::modeCreate|CFile::modeRead);

	while(File.ReadString(sTemp))
	{	
		m_SADeviceUid.Add( sTemp );
	}
	File.Close();
}
void CVariantsManager::SetDBType(char *pDBType)
{
	m_strDBType = CString(pDBType);
	CDBInterface::GetInstancePtr()->SetDBType( pDBType );
}

bool CVariantsManager::IsExistDatePlan(char *pDevUid, int nVarID)
{//0：星期一 1：星期二 6：星期天
	unsigned char	szArray[7][24];
	memset(szArray, 0, sizeof(szArray) );

	CTime time = CTime::GetCurrentTime();
	// 获取当前时间
	int nWeekOfDay = time.GetDayOfWeek();
	if( nWeekOfDay == 1 )
	{
		nWeekOfDay = 6;
	}
	else
	{
		nWeekOfDay -= 2;
	}
	int nHours = time.GetHour();

	int nRet;
	nRet = CDBInterface::GetInstancePtr()->GetDatePlan( PLAN_TYPE_EQUIP, pDevUid, nVarID, szArray );
	if( nRet > 0 )
	{
		if( 15 == szArray[nWeekOfDay][nHours] )
		{
			return true;
		}
		//for( int x=0; x<7; x++ )
		//{
		//	for(int y=0; y<24; y++)	
		//	{
		//		if( 15 == szArray[x][y] )
		//		{
		//			return true;
		//		}
		//	}
		//}
	}
	else
	{
		return true;
	}

	return false;
}

void CVariantsManager::AllocDatePlan(void)
{
	for( int i = 0; i < m_analog.GetSize(); i++ )
	{
		CAnalog *pAnalog = m_analog.GetAt(i);
		if( SYS_COMMUNCTION_VAR_ID == pAnalog->m_nVarTypeID )
		{
			pAnalog->m_bExistDatePlan = false;
		}
		else
		{
			pAnalog->m_bExistDatePlan = IsExistDatePlan( (char *)(LPCTSTR)pAnalog->m_strVarUID, pAnalog->m_nVarID );
		}
	}
}
INT CVariantsManager::GetVarInfo(void)
{
	CDBInterface::GetInstancePtr()->GetVarInfo( );
	return 0;
}
void CVariantsManager::AddSysCommunctionVar()
{
	CAnalog *pAnalog = new CAnalog();

	int nVarID;
#if 0
	if( -1 == iSize )
	{
		nVarID = 0;
	}
	else
	{
		nVarID = m_analog.GetAt(iSize)->m_nVarID + 1;
	}
#else
	nVarID = 0;
#endif

	// 变量ID
	pAnalog->m_nVarID = nVarID;

	// 变量UID
	pAnalog->m_strVarUID = "0.0.0.0";

	// 变量名称
	pAnalog->m_strName = "SystemCommunication";

	// 变量描述
	pAnalog->m_strDesc = "Server Communication Status";

	// 变量类型ID
	pAnalog->m_nVarTypeID = SYS_COMMUNCTION_VAR_ID;

	// 变量数据长度
	pAnalog->m_nDataLen = 0;

	// 开的描述
	pAnalog->m_strOnDesc = "";

	// 关的描述
	pAnalog->m_strOffDesc = "";

	// 最大值
	pAnalog->m_nMaxValues = 0;

	// 最小值
	pAnalog->m_nMinValues = 0;

	// 最大转换比率
	pAnalog->m_nMaxConvtRate = 0;

	// 最小转换比率
	pAnalog->m_nMinConvtRate = 0;
	
	// 下限
	pAnalog->m_nLowerLimit = 0;

	// 上限
	pAnalog->m_nUpperLimit = 0;

	// 正常状态
	pAnalog->m_nNormalState = 0;

	// 设定值
	pAnalog->m_strSetValue = "";

	// 校正值
	pAnalog->m_nRearm = 0;

	// 偏移量
	pAnalog->m_nOffset = 0;

	// 单位
	pAnalog->m_strUnit = "";

	// 采集频率
	pAnalog->m_nCollectFreq = 900;

	// 转换系数
	pAnalog->m_fCoef = 1.0;

	// 告警级别
	pAnalog->m_nWaringLevel = 3;

	// 读写权限
	pAnalog->m_nPurview = 0;

	// 是否保存数值
	pAnalog->m_bIsSave = TRUE;

	// 是否实时采集数据
	pAnalog->m_bRealtimeFlag = TRUE;

	// 是否记录实时曲线
	pAnalog->m_bRecCurve = FALSE;

	// 是否允许DDE访问
	pAnalog->m_bIsDDE = FALSE;

	// 请求寄存器个数
	pAnalog->m_nRegNum = 0;

	// 功能码id
	pAnalog->m_nFuncCode = 0;

	// 寄存器子id
	pAnalog->m_nVarChildID = 0;

	// 位信息id
	pAnalog->m_nVarItemID = 0;

	// SNMP对象oid
	pAnalog->m_strSnmpOid = "";
	
	// SNMP域
	pAnalog->m_strFields = "";

	// 设备类型ID
	pAnalog->m_nDevID = 0;

	// 起始地址
	pAnalog->m_nRegStartAddr = 0;

	// Rs232请求命令
	pAnalog->m_strRs232Cmd = "";

	// Rs232请求类型
	pAnalog->m_strRs232Type = "";

	// Rs232数据索引
	pAnalog->m_nRs232Index = 0;

	// 起始BIT位
	pAnalog->m_nStartBit = 0;

	pAnalog->m_nEndBit = 0;

	pAnalog->m_strReserved1 = "";
	pAnalog->m_strReserved2 = "";
	pAnalog->m_strReserved3 = "";
	pAnalog->m_strReserved4 = "";
	pAnalog->m_strReserved5 = "";
	pAnalog->m_strReserved6 = "";
	pAnalog->m_strReserved7 = "";
	pAnalog->m_strReserved8 = "";
	pAnalog->m_strReserved9 = "";
	pAnalog->m_strReserved10 = "";

	pAnalog->m_nReserved1 = 0;
	pAnalog->m_nReserved2 = 0;
	pAnalog->m_nReserved3 = 0;
	pAnalog->m_nReserved4 = 0;
	pAnalog->m_nReserved5 = 0;
	pAnalog->m_nReserved6 = 0;
	pAnalog->m_nReserved7 = 0;
	pAnalog->m_nReserved8 = 0;
	pAnalog->m_nReserved9 = 0;
	pAnalog->m_nReserved10 = 0;

	pAnalog->m_bReserved1 = FALSE;
	pAnalog->m_bReserved2 = FALSE;
	pAnalog->m_bReserved3 = FALSE;
	pAnalog->m_bReserved4 = FALSE;
	pAnalog->m_bReserved5 = FALSE;
	pAnalog->m_bReserved6 = FALSE;
	pAnalog->m_bReserved7 = FALSE;
	pAnalog->m_bReserved8 = FALSE;
	pAnalog->m_bReserved9 = FALSE;
	pAnalog->m_bReserved10 = FALSE;

	pAnalog->m_pDevice = NULL;
	int i, nChannelSize = pDevicesManager->m_channels.GetSize();
	int j, nDevicesSize;
	for( i = 0; i < nChannelSize; i++ )
	{
		nDevicesSize = pDevicesManager->m_channels[i]->m_Devices.GetSize();
		for( j = 0; j < nDevicesSize; j++ )
		{
			if( !pDevicesManager->m_channels[i]->m_Devices[j]->m_strUID.Compare(pAnalog->m_strVarUID) )
			{
				pAnalog->m_pDevice = pDevicesManager->m_channels[i]->m_Devices[j];
			}
		}
	}

	pVariantsManager->m_analog.Add(pAnalog);
}

void CVariantsManager::SetSysComunicationVar( float fData )
{
	CAnalog *pAnalog = FindAnalogByVarTypeID(SYS_COMMUNCTION_VAR_ID);
	if( NULL != pAnalog )
	{
		pAnalog->m_fData = fData;
		//LOG4C((LOG_NOTICE, "var name = %s, var= %s SetSysComunicationVar = %d", pAnalog->m_strName, pAnalog->m_strDesc, (int)pAnalog->m_fData));
	}
}

void CVariantsManager::Store(char *pStrDirectroy)
{
	CFile file;
	CString fileName = CString(pStrDirectroy) + "\\" + _PROJECTDIR;
	fileName = fileName + VARIANT_FILE;
	DeleteFile( fileName );

	if (0 != file.Open(fileName, CFile::modeWrite|CFile::modeCreate))
	{
		CArchive ar(&file,CArchive::store);
		m_analog.Serialize(ar);
		ar.Flush();
		ar.Close();
		file.Flush();
		file.Close();
	}
}

BOOL CVariantsManager::FindDevIsUse(CString strUid)
{
	BOOL bResult = FALSE;
	int nChannelSize, nDeviceSize;
	nChannelSize = pDevicesManager->m_channels.GetSize();
	for( int i = 0; i < nChannelSize; i++ )
	{
		nDeviceSize = pDevicesManager->m_channels[i]->m_Devices.GetSize();
		for( int j = 0; j < nDeviceSize; j++ )
		{
			if( !strUid.Compare( pDevicesManager->m_channels[i]->m_Devices[j]->m_strUID ) )
			{
				if( pDevicesManager->m_channels[i]->m_Devices[j]->m_bUsed == TRUE )
				{
					bResult = TRUE;
				}
			}
		}
	}
	return bResult;
}

void CVariantsManager::Fresh(CString strUid)
{
	int nVarSize = m_analog.GetSize();

	for ( int i = 0; i< nVarSize; i++)
	{
		CAnalog* analog = m_analog.GetAt(i);
		BOOL bRet = FindDevIsUse( analog->m_strVarUID );

		if( bRet == TRUE )
		{
			if( analog->m_nPurview == 0 )//只读
			{
				//LOG4C((LOG_NOTICE, "请求变量ID=%d的值", analog->m_nVarID));
				analog->Fresh(0);
				Sleep(10);			// 让CPU释放一下。
			}
		}
	}

    //FreshTime();
}
void CVariantsManager::FreshCurPic( )
{
	if( m_bIsChangeView )
	{
		m_analogCurPic.RemoveAll();

		int nVarSize = m_analogTemp.GetSize();
		for ( int i = 0; i< nVarSize; i++)
		{
			CAnalog* analog = pVariantsManager->m_analogTemp.GetAt(i);
			pVariantsManager->m_analogCurPic.Add( analog );
		}

		m_analogTemp.RemoveAll();

		m_bIsChangeView = false;
	}

	int nVarSize = m_analogCurPic.GetSize();

	if( nVarSize==0 )
		return;

	for ( int i = 0; i< nVarSize; i++)
	{
		CAnalog* analog = m_analogCurPic.GetAt(i);
		BOOL bRet = FindDevIsUse( analog->m_strVarUID );

		if( m_bIsChangeView )
			break;

		if( bRet == TRUE )
		{
			if( analog->m_nPurview == 0 )//只读
			{
				analog->Fresh(0);
				Sleep(10);			// 让CPU释放一下。
			}
		}
	}
}
// run
float CVariantsManager::GetAnalogValue(CString name)
{
	int aSize = m_analog.GetSize();
	for ( int i = 0; i < aSize; i++)
	{
		CAnalog* analog = m_analog.GetAt(i);
		if (analog->m_strName == name)
		{
			return analog->m_fData;
		}
	}
	return VARIANT_NOTFOUND;
}
// run
float CVariantsManager::GetAnalogValue(CString name,int &iLowwer,int &iUpper)
{
	int aSize = m_analog.GetSize();
	for ( int i = 0; i < aSize; i++)
	{
		CAnalog* analog = m_analog.GetAt(i);
		if (analog->m_strName == name)
		{
			iLowwer = analog->m_nLowerLimit;
			iUpper = analog->m_nUpperLimit;
			return analog->m_fData;
		}
	}
	return VARIANT_NOTFOUND;
}
// 判断变量sVarName是否报警 0正常 1报警
int CVariantsManager::VarIsAlarm( CString sVarName )
{
	int aSize = m_analog.GetSize();
	for ( int i = 0; i < aSize; i++)
	{
		CAnalog* analog = m_analog.GetAt(i);
		if (analog->m_strName == sVarName )
		{
			if( !analog->m_bReserved2 )
				return 0;

			if( analog->m_nUpperLimit==0 && analog->m_nLowerLimit==0 )
			{
				if( analog->m_fData!=analog->m_nNormalState )
					return 1;
				else
					return 0;
			}
			else 
			{
				if( analog->m_fData<analog->m_nLowerLimit || analog->m_fData>analog->m_nUpperLimit )
					return 1;
				else
					return 0;
			}
		}
	}
	return 0;
}
// 判断变量sVarName是否报警 0正常 1报警
float CVariantsManager::GetVarNormalValue( CString sVarName )
{
	int aSize = m_analog.GetSize();
	for ( int i = 0; i < aSize; i++)
	{
		CAnalog* analog = m_analog.GetAt(i);
		if (analog->m_strName == sVarName)
		{
			return analog->m_nNormalState;
		}
	}
	return 0;
}
// run
bool  CVariantsManager::IsEndIdentifyTime( CString name )
{
	bool bRet = false;

	int nIdentifyTime = 0;
	DWORD dwIdentityTick = 0;

	int aSize = m_analog.GetSize();
	for ( int i = 0; i < aSize; i++)
	{
		CAnalog* analog = m_analog.GetAt(i);
		if (analog->m_strName == name)
		{
			nIdentifyTime = analog->m_nIdentifyTime;
			dwIdentityTick = analog->m_dwIdentityTick;

			if( dwIdentityTick==0 )
			{
				dwIdentityTick = GetTickCount();
				analog->m_dwIdentityTick = dwIdentityTick;
			}

			if( GetTickCount()-dwIdentityTick > (DWORD)((analog->m_nIdentifyTime+3) * 1000) )
			{
				dwIdentityTick = 0;
				analog->m_dwIdentityTick = 0;
			}

			break;
		}
	}

	if( ( GetTickCount()-dwIdentityTick ) > (DWORD)(nIdentifyTime * 1000) )
		bRet = true;

	return bRet;
}
// run
float CVariantsManager::GetAnalogValue(CString name,CString &sVarDes )
{
	int aSize = m_analog.GetSize();
	for ( int i = 0; i < aSize; i++)
	{
		CAnalog* analog = m_analog.GetAt(i);
		if (analog->m_strName == name)
		{
			sVarDes = analog->m_strDesc;
			return analog->m_fData;
		}
	}
	return VARIANT_NOTFOUND;
}
// run
CAnalog*  CVariantsManager::FindAnalog(CString name)
{
	int aSize = m_analog.GetSize();
	for ( int i = 0; i < aSize; i++)
	{
		CAnalog* analog = m_analog.GetAt(i);
		if ( analog->m_strName.Compare(name) == 0 )
		{
			return analog;
		}
	}
	return NULL;
}
bool CVariantsManager::IsExistVar( CString sVarName )//判断变量是否存在
{
	if( sVarName=="" )
		return false;

	bool bRet = false;
	int aSize = m_analog.GetSize();
	for ( int i = 0; i < aSize; i++)
	{
		CAnalog* analog = m_analog.GetAt(i);
		if ( analog->m_strName.Compare(sVarName) == 0 )
		{
			return true;
		}
	}

	LOG4C((LOG_NOTICE, "报警联动表里有不存在的变量：sVarName=%s",sVarName));

	return bRet;
}
// run
CAnalog*  CVariantsManager::FindAnalogByUID(CString strUID)
{
	int aSize = m_analog.GetSize();
	for ( int i = 0; i < aSize; i++)
	{
		CAnalog* analog = m_analog.GetAt(i);
		if ( !analog->m_strVarUID.Compare(strUID) )
		{
			return analog;
		}
	}
	return NULL;
}

// run
CAnalog*  CVariantsManager::FindAnalog(int nVarID)
{
	int aSize = m_analog.GetSize();
	for ( int i = 0; i < aSize; i++)
	{
		CAnalog* analog = m_analog.GetAt(i);
		if ( analog->m_nVarID == nVarID )
		{
			return analog;
		}
	}
	return NULL;
}

// run
CString  CVariantsManager::GetVarNameByID(int nVarID)
{
	int aSize = m_analog.GetSize();
	for ( int i = 0; i < aSize; i++)
	{
		CAnalog* analog = m_analog.GetAt(i);
		if ( analog->m_nVarID == nVarID )
		{
			return analog->m_strName;
		}
	}
	return "";
}


// run
CAnalog*  CVariantsManager::FindAnalogByVarTypeID(int nVarTypeID)
{
	int aSize = m_analog.GetSize();
	for ( int i = 0; i < aSize; i++)
	{
		CAnalog* analog = m_analog.GetAt(i);
		if ( analog->m_nVarTypeID == nVarTypeID )
		{
			return analog;
		}
	}
	return NULL;
}

BOOL  CVariantsManager::DeleteAnalog(int nVarID)
{
	int aSize = m_analog.GetSize();
	for ( int i = 0; i < aSize; i++)
	{
		CAnalog* analog = m_analog.GetAt(i);
		if ( analog->m_nVarID == nVarID )
		{
			list<int>::iterator it;
			list<CString>::iterator it_desc;

			for( it = analog->m_listStatusID.begin(); it != analog->m_listStatusID.end(); )
			{
				analog->m_listStatusID.erase( it++ );
			}

			for( it_desc = analog->m_listStatusDesc.begin(); it_desc != analog->m_listStatusDesc.end(); )
			{
				analog->m_listStatusDesc.erase( it_desc++ );
			}

			delete m_analog[i];
			m_analog.RemoveAt(i);
			return TRUE;
		}
	}
	return FALSE;
}

// run
void CVariantsManager::SaveDayStatistic(int year, int month, int day)
{
	int aSize = m_analog.GetSize();
#if 0
	CDataList* pSaveDataList = new CDataList();
	for ( int i = 0; i < aSize; i++)
	{
		CAnalog* analog = m_analog.GetAt(i);
		if ( analog->m_bSave )
		{
			CDataUnit* unit = new CDataUnit();
			unit->max = analog->m_fDayMax;
			unit->ave = analog->m_fDayAvg;
			unit->min = analog->m_fDayMin;
			unit->day = day;
			unit->var = analog->m_strName;
			pSaveDataList->AddTail(unit);
		}
	}
	SaveMonthData(year, month, pSaveDataList);

	POSITION pos = pSaveDataList->GetHeadPosition();
	while (pos != NULL) 
    {
        delete pSaveDataList->GetNext(pos);
    }
	pSaveDataList->RemoveAll();
#endif
}


// run
void CVariantsManager::InitDayStatistic(int day)
{
	int aSize = m_analog.GetSize();
	for ( int i = 0; i < aSize; i++)
	{
		CAnalog* analog = m_analog.GetAt(i);
		analog->m_fDayMax = analog->m_fData;
		analog->m_fDayAvg = analog->m_fData;
		analog->m_fDayMin = analog->m_fData;
		analog->m_nMinCount = 0;
		analog->m_nDay = day;
	}
}

// run
void CVariantsManager::SaveHourData(int year, int month, int day, int hour)
{
	int aSize = m_analog.GetSize();
#if 0
	CDataList* pSaveDataList = new CDataList();
	for ( int i = 0; i < aSize; i++)
	{
		CAnalog* analog = m_analog.GetAt(i);
		if ( analog->m_bSave )
		{
			CDataUnit* unit = new CDataUnit();
			unit->data = analog->m_fData;
			unit->day = day;
			unit->hour = hour;
			unit->minute = 0;
			unit->second = 0;
			unit->type = HOUR;
			unit->var = analog->m_strName;
			pSaveDataList->AddTail(unit);
		}
	}
	SaveDayData(year, month, day, pSaveDataList);
#endif
}
// run
BOOL CVariantsManager::SetAnalogValue(CString name, double value)
{
	int aSize = m_analog.GetSize();
	for ( int i = 0; i < aSize; i++)
	{
		CAnalog* analog = m_analog.GetAt(i);
		if (analog->m_strName == name)
		{
			analog->SetValue((float)value );
			analog->m_dwIdentityTick = 0;
			return TRUE;
		}
	}
	return FALSE;
}

void CVariantsManager::GetAnalogNameArray(CStringArray &nameArray)
{
	nameArray.RemoveAll();
    int aSize = m_analog.GetSize();
	for ( int i = 0; i < aSize; i++)
	{
		CAnalog* analog = m_analog.GetAt(i);
		nameArray.Add(analog->m_strName);
	}   
}

void CVariantsManager::FreshTime()
{
	SYSTEMTIME st;
	GetLocalTime(&st);
	m_nMinutes = st.wHour * 60 + st.wMinute;
}