// DispatchTaskManger.cpp : 定义 DLL 的初始化例程。
#include "pch.h"
#include <YD_Public_OCC.h>
#include "NetWork_Alone.h"
#include "DispatchTaskManger.h"

#if defined(_MSC_VER) || defined(WIN64) || defined(__WIN64__) || defined(WIN32) || defined(_WIN32)
#ifdef  _YD_OCC_DISPATCHTASK_MG_SDK
#define _YD_OCC_DISPATCHTASK_MG_API __declspec(dllexport)
#else
#define _YD_OCC_DISPATCHTASK_MG_API __declspec(dllimport)
#endif

#else //linux
#ifdef  _YD_OCC_DISPATCHTASK_MG_SDK
#define _YD_OCC_DISPATCHTASK_MG_API __attribute__ ((visibility("default")))
#else
#define _YD_OCC_DISPATCHTASK_MG_API __attribute__ ((visibility("default")))
#endif 
#endif

extern "C" _YD_OCC_DISPATCHTASK_MG_API CDispatchMng_I* CreateDispatchServer(CFrameTool_I * pFrmTool)
{
	//1、直接返回-指针为空时
	CDispatchTaskMG* pDispatchMng = new CDispatchTaskMG();
	if ( !pDispatchMng )  return nullptr;

	//2、开始任务失败-析构对象并返回空
	if ( !(pDispatchMng->StartWork(pFrmTool)) )
	{
		delete pDispatchMng;
		pDispatchMng = nullptr;
	}
	return pDispatchMng;
}

//构造函数
CDispatchTaskMG::CDispatchTaskMG( )
{

}

//析构函数
CDispatchTaskMG::~CDispatchTaskMG(void)
{
	EXIT netoder;
	netoder.time = (int)time(nullptr);
	NetComand_Send(&netoder,OCC_SYS_SERVER_ADMIN,OCCCOMMAND::eExit);

	//1、首先关闭网络连接
	if ( m_pNetWork )
	{
		m_pNetWork->_IClose();
		delete m_pNetWork;
		m_pNetWork = nullptr;
	}

	//2、结束接收TCP数据线程
	m_ReceiveMsgThreadOut		= true;
	if ( m_Thread_DealTCPData.joinable() )
	{
		m_Thread_DealTCPData.join();
	}

	//3、结束接收组播数据线程
	m_ReceiveGroupMsgThreadOut	= true;
	if ( m_Thread_DealGroupData.joinable() )
	{
		m_Thread_DealGroupData.join();
	}

	//4、结束接收UDP数据线程
	m_ReceiveRealMsgThreadOut	= true;
	if ( m_Thread_DealUDPData.joinable() )
	{
		m_Thread_DealUDPData.join();
	}

	//5、结束回滚记录线程
	m_RollBackRecordThreadOut = true;
	if ( m_Thread_RollBackRecord.joinable() )
	{
		m_Thread_RollBackRecord.join();
	}

	//6、删除训练
	DELTRAIN tb;
	tb.CourseID	 = 0;
	tb.SysID     = OCC_SYS_LS_SVR;
	DeleteDispatchTask(tb.CourseID,tb.SysID,0);
	
	tb.CourseID	 = 0;
	tb.SysID     = OCC_SYS_XD_SVR;
	DeleteDispatchTask(tb.CourseID,tb.SysID,0);
	
	tb.CourseID	 = 0;
	tb.SysID     = OCC_SYS_DD_SVR;
	DeleteDispatchTask(tb.CourseID,tb.SysID,0);
	
	tb.CourseID	 = 0;
	tb.SysID     = OCC_SYS_HD_SVR;
	DeleteDispatchTask(tb.CourseID,tb.SysID,0);

	tb.CourseID	 = 0;
	tb.SysID     = OCC_SYS_KC_SVR;
	DeleteDispatchTask(tb.CourseID,tb.SysID,0);

	//7、各子模块停止任务并退出
	R_Mutex_LOCK(m_MutexDispatchTask);
	for( auto& var : m_DispatchTasksMap )
	{
		if ( var.second )
		{
			int ret;
			var.second->StopTask(ret);
			var.second->Exit();
			delete var.second;
			var.second = nullptr;
		}
	}
	m_DispatchTasksMap.clear();
}

/*******************************************************
函数名称: StartWork
函数功能: 开始工作
输入参数: pFrmTool - 框架工具
输出参数: NULL
返 回 值: void
*******************************************************/

bool CDispatchTaskMG::StartWork( CFrameTool_I* pFrmTool )
{
	bool bFlag			= CBaseDispatchTaskMg::StartWork(pFrmTool);
	m_pTCPSend_CallBack = pFrmTool->m_pTCPSend_CallBack;
	m_pUDPSend_CallBack = pFrmTool->m_pUDPSend_CallBack;

	//1、TODO:加载网络库
	if ( m_pTCPSend_CallBack && m_pUDPSend_CallBack )
	{
		m_pNetWork = new CNetWork_Alone(this);
	}
	else
	{
		NEW_NETWORK_INSTANCE NewInstanceFun		= nullptr;
#ifdef IN_WINDOWS
		std::string Str_LibName		= GetFolder_Module_2() + "\\NetWorkManger.dll";
		HINSTANCE hInstance			= ::LoadLibraryA(Str_LibName.c_str());
		NewInstanceFun				= (NEW_NETWORK_INSTANCE)GetProcAddress(hInstance,"New_NetWork_Ins");
#else
		std::string Str_LibName		= GetFolder_Module_2() + "libNetWorkManger.so";
		HINSTANCE hInstance			= dlopen(Str_LibName.c_str(),RTLD_LAZY);
		NewInstanceFun				= (NEW_NETWORK_INSTANCE)dlsym(hInstance, "New_NetWork_Ins");
#endif
		if ( NewInstanceFun )
		{
			m_pNetWork		= NewInstanceFun(this);
			m_NetServerID	= m_pNetWork->_IGet_System_ID();
		}
	}
	return bFlag;
}

/*******************************************************
函数名称: InitConfigParam
函数功能: 初始化配置参数
输入参数: NULL
输出参数: NULL
返回值  : bool   - true:成功 false:失败
*******************************************************/

bool CDispatchTaskMG::InitConfigParam()
{
	bool bFlag = true;
	for ( auto var : m_PluginMap )
	{
		int nSubSysType = var.first;
		if ( !LoadSubSys_DBConfig(nSubSysType) )
		{
			bFlag = false;
		}
	}
	return bFlag;
}

/*******************************************************
函数名称: LoadSubSys_DBConfig
函数功能: 加载子系统数据库配置文件
输入参数: nSubSysType - 子系统类型
输出参数: NULL
返回值  : BOOL   - TRUE:成功 FALSE:失败
*******************************************************/

BOOL CDispatchTaskMG::LoadSubSys_DBConfig( int nSubSysType )
{
	//1、先按网络配置设置默认数据库IP和NAME
	std::string Str_FilePath		= GetFolder_Module_2();

#ifdef IN_WINDOWS
	std::string Str_FileName		= Str_FilePath+"\\YDComm.conf";
#else
	std::string Str_FileName		= Str_FilePath + "YDComm.conf";
#endif

	std::string StrTmp				= ReadCfg_String(Str_FileName, "DATABASE", "DatabaseAddr", "");
	vector <std::string> TmpVecStr	= str_split_2(StrTmp, ";");
	int nDB_Type					= TmpVecStr.size() > 3  ? atoi(TmpVecStr.at(3).c_str()) : 0;
	std::string Str_DefDBIP			= TmpVecStr.size() >= 3 ? TmpVecStr.at(0) : "Error";
	std::string Str_DefDBName		= TmpVecStr.size() >= 3 ? TmpVecStr.at(2) : "Error";
	std::string Str_DefUser			= TmpVecStr.size() > 3  ? "yd_fms"  : "yd_fms";
	std::string Str_Psw				= nDB_Type		   == 1 ? "fms@123"	 : "fms";
	
	
	
	//2、设置子系统数据库配置关键Key
	char cMainKey[25];
	memset(cMainKey, 0, sizeof(cMainKey));
	switch (nSubSysType)
	{
	case OCC_SYS_LS_SVR:
		Str_To_CharBuf_2("LSDATABASE", cMainKey, 25);
		break;
	case OCC_SYS_XD_SVR:
		Str_To_CharBuf_2("XDDATABASE", cMainKey, 25);
		break;
	case OCC_SYS_DD_SVR:
		Str_To_CharBuf_2("DDDATABASE", cMainKey, 25);
		break;
	case OCC_SYS_HD_SVR:
		Str_To_CharBuf_2("HDDATABASE", cMainKey, 25);
		break;
	case OCC_SYS_JT_SVR:
		Str_To_CharBuf_2("XDDATABASE", cMainKey, 25);
		break;
	case OCC_SYS_KC_SVR:
		Str_To_CharBuf_2("KCDATABASE", cMainKey, 25);
		break;
	default:
		Str_To_CharBuf_2("XDDATABASE", cMainKey, 25);
		break;
	}

	//3、加载数据库配置文件
#ifdef IN_WINDOWS
	Str_FileName = Str_FilePath + "\\ParamSetting.ini";
#else
	Str_FileName = Str_FilePath + "ParamSetting.ini";
#endif
	DATEBASECONFIG DataBaseConfig;
	DataBaseConfig.strSeverIP	= ReadCfg_String(Str_FileName, cMainKey, "ServerIP", Str_DefDBIP);
	DataBaseConfig.strDBName	= ReadCfg_String(Str_FileName, cMainKey, "DBname",	Str_DefDBName);
	DataBaseConfig.strUserID	= ReadCfg_String(Str_FileName, cMainKey, "Username", Str_DefUser);
	DataBaseConfig.strPassWord	= ReadCfg_String(Str_FileName, cMainKey, "PassWord", Str_Psw);
	DataBaseConfig.nDB_Type		= nDB_Type;


	//DataBaseConfig.strSeverIP.TrimLeft();
	//DataBaseConfig.strSeverIP.TrimRight();
	//DataBaseConfig.strDBName.TrimLeft();
	//DataBaseConfig.strDBName.TrimRight();
	//DataBaseConfig.strUserID.TrimLeft();
	//DataBaseConfig.strUserID.TrimRight();
	//DataBaseConfig.strPassWord.TrimLeft();
	//DataBaseConfig.strPassWord.TrimRight();

	//4、判断数据库配置正确性并存储配置文件
	if ( DataBaseConfig.strSeverIP  == "Error" || DataBaseConfig.strSeverIP.empty())
		return FALSE;
	if ( DataBaseConfig.strDBName   == "Error" || DataBaseConfig.strDBName.empty())
		return FALSE;
	if ( DataBaseConfig.strUserID   == "Error" || DataBaseConfig.strUserID.empty())
		return FALSE;
	if ( DataBaseConfig.strPassWord == "Error" || DataBaseConfig.strPassWord.empty())
		return FALSE;

	//5、存储配置文件
	m_DataBaseConfigMap.insert(make_pair(nSubSysType,DataBaseConfig));
	return TRUE;
}

/*******************************************************
函数名称: CreateNewTaskType
函数功能: 创建新的任务类型
输入参数: nSysType - 系统类型
输出参数: NULL
返回值  : CBaseDispatch* - 创建的调度对象指针
*******************************************************/

CBaseDispatch*  CDispatchTaskMG::CreateNewTaskType( int nSysType )
{
	CBaseDispatch* pDispatchSys = NULL;
	//创建子模块
	sPlugin* pPlugin = GetPlugin_ByModuleID(nSysType);
	if ( pPlugin && pPlugin->bInitOk )
	{
		pDispatchSys = pPlugin->nCreatePlug();
	}

	//初始化调试工具
	if ( pDispatchSys ) 
	{
		pDispatchSys->Dispatch_ModuleInit(this);
	}
	return pDispatchSys;
}


void CDispatchTaskMG::Deal_NetComand( OCCCOMMAND& NetCmd )
{
	 if ( NetCmd.cmdType == OCCCOMMAND::eCreateConnect )
	{
		OCCORDER oder;
		oder.sysID		= OCC_SYS_SERVER_SVR;
		oder.cmdType	= OCC_NETMESSAGE_TRIAN_CREATETCP;
		oder.data1		= NetCmd.NET_JY_CREATECONNECT.SysType;
		oder.data2		= NetCmd.NET_JY_CREATECONNECT.SysID;
		oder.trainID	= -1;
		NetComand_Send(&oder,OCC_SYS_SERVER_NET,OCCCOMMAND::eOccOrder);
	}

	 if ( NetCmd.cmdType == OCCCOMMAND::CMD_SYS_ReConnec )
	 {
		 OCCORDER oder;
		 oder.sysID		= OCC_SYS_SERVER_SVR;
		 oder.cmdType	= OCC_NETMESSAGE_TRIAN_RESETNETROOM;
		 oder.trainID	= -1;
		 NetComand_Send(&oder,OCC_SYS_SERVER_NET,OCCCOMMAND::eOccOrder);
	 }
}


void CDispatchTaskMG::AddReceiveGroupMsg(int nTrainID, int nSysType, CBaseDispatch* pDispatchSys)
{
	//NOTE:暂时先屏蔽此函数功能，觉得没什么用
	return;

	int nGroupSys = -1;
	switch (nSysType)
	{
	case OCC_SYS_XD_SVR:
		nGroupSys = OCC_SYS_XD_GROUP;
		break;
	case OCC_SYS_DD_SVR:
		nGroupSys = OCC_SYS_DD_GROUP;
		break;
	case OCC_SYS_HD_SVR:
		nGroupSys = OCC_SYS_HD_GROUP;
		break;
	default:
		break;
	}
	if ( nGroupSys <= 0 )  return;

	std::string Str_Key = Make2IntKey_2(nGroupSys,nTrainID);

	R_Mutex_LOCK(m_MutexDispatchTask);
	m_DispatchTasksMap.insert(make_pair(Str_Key,pDispatchSys));
}

/*******************************************************
函数名称: InitNetConnectStatus
函数功能: 初始化网络连接状态
输入参数: nTrainID - 训练号
		  systype - 系统类型
输出参数: NULL
返回值  : CBaseDispatch* - 创建的调度对象指针
*******************************************************/

bool CDispatchTaskMG::InitNetConnectStatus( int nTrainID,int nSysType )
{
	R_Mutex_LOCK(m_MutexTrainConect);
	auto iter  = m_NetTrainNectMap.find(nTrainID);
	if ( iter != m_NetTrainNectMap.end() )
	{
		if ( iter->second.nSvrSysID_XD == m_NetServerID && nSysType == OCC_SYS_XD_SVR )
		{
			for ( size_t i = 0; i < iter->second.ClientSysID_XD.size(); i++ )
			{
				//  OCCORDER oder;
				//  oder.sysID		= OCC_SYS_SERVER_SVR;
				// 	oder.cmdType	= OCC_NETMESSAGE_TRIAN_CREATETCP;
				// 	oder.data1		= OCC_SYS_XD_CLIENT;
				// 	oder.data2		= iter->second.xdclientsysid[i];
				// 	oder.trainID	= -1;
				// 	NetComand_Send(&oder,OCC_SYS_SERVER_NET,OCCCOMMAND::eOccOrder);
			}
			if ( iter->second.nSvrGroupID_XD > 0 )
			{
				OCCORDER oder;
				oder.sysID		= OCC_SYS_SERVER_SVR;
				oder.cmdType	= OCC_NETMESSAGE_TRIAN_JIONGROUP;
				oder.data1		= OCC_SYS_XD_GROUP;
				oder.data2		= iter->second.nSvrGroupID_XD;
				oder.trainID	= nTrainID;
				NetComand_Send(&oder,OCC_SYS_SERVER_NET,OCCCOMMAND::eOccOrder);
			}

		}
		if ( iter->second.nSvrSysID_HD == m_NetServerID && nSysType == OCC_SYS_HD_SVR )
		{
			for (size_t i=0;i<iter->second.ClientSysID_HD.size();i++)
			{
				// OCCORDER oder;
				// oder.sysID	= OCC_SYS_SERVER_SVR;
				// oder.cmdType = OCC_NETMESSAGE_TRIAN_CREATETCP;
				// oder.data1	= OCC_SYS_HD_CLIENT;
				// oder.data2	= iter->second.hdclientsysid[i];
				// oder.trainID	= -1;
				// NetComand_Send(&oder,OCC_SYS_SERVER_NET,OCCCOMMAND::eOccOrder);
			}
			if ( iter->second.nSvrGroupID_HD > 0 )
			{
				OCCORDER oder;
				oder.sysID   = OCC_SYS_SERVER_SVR;
				oder.cmdType = OCC_NETMESSAGE_TRIAN_JIONGROUP;
				oder.data1   = OCC_SYS_HD_GROUP;
				oder.data2   = iter->second.nSvrGroupID_HD;
				oder.trainID = nTrainID;
				NetComand_Send(&oder,OCC_SYS_SERVER_NET,OCCCOMMAND::eOccOrder);
			}
		}
		if ( iter->second.nSvrSysID_DD == m_NetServerID && nSysType == OCC_SYS_DD_SVR )
		{
			for ( size_t i = 0; i < iter->second.ClientSysID_DD.size(); i++ )
			{
				//OCCORDER oder;
				//oder.sysID	= OCC_SYS_SERVER_SVR;
				//oder.cmdType	= OCC_NETMESSAGE_TRIAN_CREATETCP;
				//oder.data1	= OCC_SYS_DD_CLIENT;
				//oder.data2	= iter->second.ddclientsysid[i];
				//oder.trainID	= -1;
				//NetComand_Send(&oder,OCC_SYS_SERVER_NET,OCCCOMMAND::eOccOrder);
			}
			if ( iter->second.nSvrGroupID_DD > 0 )
			{
				OCCORDER oder;
				oder.sysID		= OCC_SYS_SERVER_SVR;
				oder.cmdType	= OCC_NETMESSAGE_TRIAN_JIONGROUP;
				oder.data1		= OCC_SYS_DD_GROUP;
				oder.data2		= iter->second.nSvrGroupID_DD;
				oder.trainID	= nTrainID;
				NetComand_Send(&oder,OCC_SYS_SERVER_NET,OCCCOMMAND::eOccOrder);
			}
		}
		if ( iter->second.nSvrSysID_LS == m_NetServerID && nSysType == OCC_SYS_LS_SVR )
		{
			for ( size_t i = 0; i < iter->second.ClientSysID_XD.size(); i++ )
			{
				// OCCORDER oder;
				// oder.sysID	= OCC_SYS_SERVER_SVR;
				// oder.cmdType = OCC_NETMESSAGE_TRIAN_CREATETCP;
				// oder.data1	= OCC_SYS_XD_CLIENT;
				// oder.data2	= iter->second.xdclientsysid[i];
				// oder.trainID	= -1;
				// NetComand_Send(&oder,OCC_SYS_SERVER_NET,OCCCOMMAND::eOccOrder);
			}
		}
		if ( iter->second.nSvrSysID_HD > 0 )
		{

		}
		Thread_Sleep(100);
		return true;
	}
	return false;
}


void CDispatchTaskMG::DeleteReceiveGroupMsg( int nTrainID,int nSysType )
{
	//1、按照系统类型查询组播号
	int nTmpGroupID = -1;
	switch ( nSysType )
	{
	case OCC_SYS_XD_SVR:
		nTmpGroupID = OCC_SYS_XD_GROUP;
		break;
	case OCC_SYS_DD_SVR:
		nTmpGroupID = OCC_SYS_DD_GROUP;
		break;
	case OCC_SYS_HD_SVR:
		nTmpGroupID = OCC_SYS_HD_GROUP;
		break;
	default:
		nTmpGroupID = -1;
		break;
	}

	//2、若查询组播号失败则直接返回
	if ( nTmpGroupID < 0 )		return;

	//3、查询并删除指定的组播
	string Str_Key = Make2IntKey_2(nTmpGroupID,nTrainID);

	R_Mutex_LOCK(m_MutexDispatchTask);
	auto iter  = m_DispatchTasksMap.find(Str_Key);
	if ( iter != m_DispatchTasksMap.end() )
	{
		m_DispatchTasksMap.erase(iter);
	}
}

/*******************************************************
函数名称: _IGetPtr_CmdQueue
函数功能: 获取指定类型的数据队列
输入参数: nType    - 类型
输出参数: NULL
返 回 值: LPVOID   - 队列指针
*******************************************************/

LPVOID CDispatchTaskMG::_IGetPtr_CmdQueue( int nType )
{
	CommandQueue* pCmdQueue = nullptr;
	switch ( nType )
	{
	case CmdQueueType_Send_TCP:			//发送队列-TCP
		pCmdQueue = &m_QI_SendList_TCP;
		break;
	case CmdQueueType_Send_UDP:			//发送队列-UDP
		pCmdQueue = &m_QI_SendList_UDP;
		break;
	case CmdQueueType_Send_GROUP:		//发送队列-组播
		pCmdQueue = &m_QI_SendList_Group;
		break;
	case CmdQueueType_Recv_TCP:			//接收队列-TCP
		pCmdQueue = &m_QI_GetList_TCP;
		break;
	case CmdQueueType_Recv_UDP:			//接收队列-UDP
		pCmdQueue = &m_QI_GetList_UDP;
		break;
	case CmdQueueType_Recv_GROUP:		//接收队列-组播
		pCmdQueue = &m_QI_GetList_Group;
		break;
	default:
		break;
	}
	return pCmdQueue;
}

BOOL CDispatchTaskMG::_ITCPData_2Server(char* pData, int nDateLen)
{
	OCCCOMMAND NetCmd;
	int nSizeOff = 0;
	memcpy(&NetCmd.cmdType,				pData + nSizeOff, sizeof(NetCmd.cmdType)   );		nSizeOff += sizeof(NetCmd.cmdType);
	memcpy(&NetCmd.DesSysType,			pData + nSizeOff, sizeof(NetCmd.DesSysType));		nSizeOff += sizeof(NetCmd.DesSysType);
	memcpy(&NetCmd.ScrSysType,			pData + nSizeOff, sizeof(NetCmd.ScrSysType));		nSizeOff += sizeof(NetCmd.ScrSysType);
	memcpy(&NetCmd.DesNetID,			pData + nSizeOff, sizeof(NetCmd.DesNetID)  );		nSizeOff += sizeof(NetCmd.DesNetID);
	memcpy(&NetCmd.ScrNetID,			pData + nSizeOff, sizeof(NetCmd.ScrNetID)  );		nSizeOff += sizeof(NetCmd.ScrNetID);
	memcpy(&NetCmd.TrainningID,			pData + nSizeOff, sizeof(NetCmd.TrainningID));		nSizeOff += sizeof(NetCmd.TrainningID);
	memcpy(&NetCmd.DateLen,				pData + nSizeOff, sizeof(NetCmd.DateLen)    );		nSizeOff += sizeof(NetCmd.DateLen) + 4;
	memcpy(&NetCmd.Net_CCTVCtrl_ToXD,	pData + nSizeOff, NetCmd.DateLen);
	m_QI_GetList_TCP.push(NetCmd);
	return TRUE;
}

BOOL CDispatchTaskMG::_IUDPData_2Server(char* pData, int nDateLen)
{
	OCCCOMMAND NetCmd;
	int nSizeOff = 0;
	memcpy(&NetCmd.cmdType,				pData + nSizeOff, sizeof(NetCmd.cmdType));			nSizeOff += sizeof(NetCmd.cmdType);
	memcpy(&NetCmd.DesSysType,			pData + nSizeOff, sizeof(NetCmd.DesSysType));		nSizeOff += sizeof(NetCmd.DesSysType);
	memcpy(&NetCmd.ScrSysType,			pData + nSizeOff, sizeof(NetCmd.ScrSysType));		nSizeOff += sizeof(NetCmd.ScrSysType);
	memcpy(&NetCmd.DesNetID,			pData + nSizeOff, sizeof(NetCmd.DesNetID));			nSizeOff += sizeof(NetCmd.DesNetID);
	memcpy(&NetCmd.ScrNetID,			pData + nSizeOff, sizeof(NetCmd.ScrNetID));			nSizeOff += sizeof(NetCmd.ScrNetID);
	memcpy(&NetCmd.TrainningID,			pData + nSizeOff, sizeof(NetCmd.TrainningID));		nSizeOff += sizeof(NetCmd.TrainningID);
	memcpy(&NetCmd.DateLen,				pData + nSizeOff, sizeof(NetCmd.DateLen));			nSizeOff += sizeof(NetCmd.DateLen)+ 4;
	memcpy(&NetCmd.Net_CCTVCtrl_ToXD,	pData + nSizeOff, NetCmd.DateLen);
	m_QI_GetList_UDP.push(NetCmd);
	return TRUE;
}

/*******************************************************
函数名称: _IAdd_Sub_Sys
函数功能: 添加子系统
输入参数: nTrainingID - 训练号
		  nSysType    - 系统类型
		  nSysID      - 系统号
输出参数: NULL
返 回 值: void
*******************************************************/

void  CDispatchTaskMG::_IAdd_Sub_Sys(int nTrainingID, int nSysType, int nSysID)
{
	RecTrianPosition(nSysType, nTrainingID, nSysID);
}

/*******************************************************
函数名称: _ISend_UDPData_ToModule
函数功能: 发送特殊UDP数据给模块
输入参数: nModuleID     - 模块号
		  lSysID		- 系统号
		  pDataBuf		- 数据指针
		  nLength		- 数据长度
输出参数: NULL
返 回 值: BOOL   - TRUE:成功 FALSE:失败
*******************************************************/

BOOL CDispatchTaskMG::_ISend_UDPData_ToModule( int nModuleID, long lSysID,
											   char* pDataBuf,int nLength )
{
	BOOL bFlag			= FALSE;
	string Str_Index	= Make2IntKey_2(nModuleID, m_nCurTrainID);

	R_Mutex_LOCK(m_MutexDispatchTask);
	auto itor  = m_DispatchTasksMap.find(Str_Index);
	if ( itor != m_DispatchTasksMap.end() )
	{
		itor->second->DealWith_Special_UDPData(lSysID,pDataBuf,nLength);
		bFlag = TRUE;
	}
	return bFlag;
}