server/YAServerDlg.cpp

// YAServerDlg.cpp : 实现文件
//
#include "stdafx.h"
#include "YAServer.h"	
#include "YAServerDlg.h"
#include "afxdialogex.h"

#include <stdio.h>
#include <sio_client.h>
//#include <functional>
//#include <thread> // c++11init_reader
//#include <mutex>  // c++11
#include <condition_variable>
#include <string>

#include "def.h"
#include "socketdef.h"
#include <Functions/Functions.h>
#include <json/json.h>

#include "MysqlConnPool.h"
#include "locate_algorithm.h"
//#include "parse_data.h"
#include <strconv/strconv.h>
#include <kalman/locate.h>
#include <INIFILE.h>
#include "log_def.h"
#include "DbSettingDlg.h"
#include "LogSetting.h"
#include "SysSetting.h"

//#define CM_PIX  113.3 // (100.0 * 17.0 / 15.0) //每m像素数
//#define CM_PIX 100 //  360.0/7.20 // 认证
//#define CM_PIX 1.15 // 440 / 380m
//#define CM_PIX (1.0 / 30.0)
#define STR_LEN_TIME 30

#ifdef _DEBUG
#ifndef DEBUG_NEW
#define new DEBUG_NEW
#endif
#endif

//CalLocation cal_locate(0.05, 1, 0.3, 0.3);
//CalLocation cal_locate1(0.0064, 1, 0.01);
//CalLocation cal_locate2(0.0064, 1, 0.25);
//CalLocation cal_locate3(0.0064, 0.09, 0.01);
//CalLocation cal_locate4(0.0004, 1, 0.01);
//bool is_init_calman = false;
//Point2* Anc1;
//CStdioFile std_file(L"d:\mat3_log.txt", CFile::modeCreate|CFile::modeNoTruncate|CFile::modeWrite|CFile::shareDenyNone);
// 用于应用程序“关于”菜单项的 CAboutDlg 对话框

//int aa = 0;

DWORD g_tickcount;
DWORD g_diffTickCount = 0;

class CAboutDlg : public CDialogEx
{
public:
	CAboutDlg();

	// 对话框数据
	enum { IDD = IDD_ABOUTBOX };

protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV 支持

	// 实现
protected:
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialogEx(CAboutDlg::IDD)
{
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialogEx)
END_MESSAGE_MAP()

// CYAServerDlg 对话框

CYAServerDlg::CYAServerDlg(CWnd* pParent /*=NULL*/)
	: CDialogEx(CYAServerDlg::IDD, pParent),
	_server(this),
	_io(new client())
{
	ws_init();
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CYAServerDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_BTN_START, m_btStart);
	DDX_Control(pDX, IDC_BTN_STOP, m_btStop);
	DDX_Control(pDX, IDC_LIST_READER, m_listctrl_reader);
	DDX_Control(pDX, IDC_LIST_LOG, m_list_log);	
}

BEGIN_MESSAGE_MAP(CYAServerDlg, CDialogEx)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_WM_TIMER()
	ON_BN_CLICKED(IDC_BTN_START, &CYAServerDlg::OnBnStart)
	ON_BN_CLICKED(IDC_BTN_STOP, &CYAServerDlg::OnBnStop)
	ON_BN_CLICKED(IDC_BTN_EXIT, &CYAServerDlg::OnBnExit)
	ON_BN_CLICKED(IDC_BTN_SYNCTIME, &CYAServerDlg::OnBnSyncTime)
	ON_MESSAGE(WM_ON_MONITOR, on_monitor)
	ON_COMMAND(ID_MENU_DB, &CYAServerDlg::OnMenuDb)
	ON_COMMAND(ID_MENU_LOG, &CYAServerDlg::OnMenuLog)
	ON_COMMAND(ID_MENU_PARAM, &CYAServerDlg::OnMenuParam)
	ON_BN_CLICKED(IDC_BTN_HIS, &CYAServerDlg::OnBnCallHisData)
	ON_MESSAGE(MSG_REFRESH_IP_LIST, &CYAServerDlg::OnMsgRefreshIpList)
END_MESSAGE_MAP()

// CYAServerDlg 消息处理程序

UINT WaitForS(int nSecond,bool bSleep=false)//用于等待一段时间的函数,普通精度的，参数单位秒	
{
	COleDateTime start_time = COleDateTime::GetCurrentTime();
	COleDateTimeSpan end_time = COleDateTime::GetCurrentTime()-start_time;
	while(end_time.GetTotalSeconds() < nSecond){
		if(!bSleep){
			MSG msg;
			PeekMessage(&msg,NULL,0,0,PM_NOREMOVE);
			TranslateMessage(&msg); 
			DispatchMessage(&msg);
			//以上四行是实现在延时或定时期间能处理其他的消息，降低CPU的占有率，但也降低延时或定时精度
		}
		Sleep(80);
		end_time = COleDateTime::GetCurrentTime()-start_time;
	}
	return 0;
}

UINT WaitForMS(int mSecond,bool bSleep=false)//高精度的等待函数，参数单位毫秒
{
	double dfFreq; 
	LARGE_INTEGER litmp; 
	QueryPerformanceFrequency(&litmp);
	dfFreq = (double)litmp.QuadPart;// 获得计数器的时钟频率

	QueryPerformanceCounter(&litmp);
	LONGLONG QPart0 = litmp.QuadPart;// 获得初始值
	while((double)(litmp.QuadPart-QPart0)/dfFreq < double(mSecond/1000)){
		if(!bSleep){
			MSG msg;
			PeekMessage(&msg,NULL,0,0,PM_NOREMOVE);
			TranslateMessage(&msg); 
			DispatchMessage(&msg);
			//以上四行是实现在延时或定时期间能处理其他的消息，降低CPU的占有率，但也降低延时或定时精度
		}
		QueryPerformanceCounter(&litmp);
	}
	return 0;
}

ULONGLONG time_send_json_counting;
ULONGLONG time_send_json_device_state;
ULONGLONG time_send_json_alarm;
ULONGLONG time_send_json_postion;
ULONGLONG time_sync_reader_time;
ULONGLONG time_clear_call_time;
ULONGLONG time_send_call;
bool g_exit=false;
long giSqlCount=0;
long giSqlThreadCount=0;
long gSqlTimes=0;
long giAllSqlCount=0;
long giAllThreadCount=0;
HANDLE hSemaHandle=NULL;

UINT _exec_sql(LPVOID lparam)
{
	InterlockedIncrement(&giSqlThreadCount);
	CYAServerDlg *pFrame = reinterpret_cast <CYAServerDlg*>(theApp.m_pMainWnd);
	SQLTHREAD_DATA* pSQLData= (SQLTHREAD_DATA*)lparam;
	char* strSQL=pSQLData->pText;
	if(strlen(strSQL)==0){ // SQL语句为空
		free(strSQL);
		strSQL=NULL;
		delete pSQLData;
		pSQLData=NULL;
		return 1;
	}
	int RepeatTimes=pSQLData->nRepeatTimes;
	if(RepeatTimes>0){ // 等待重试写入数据库
		Sleep(5000);
	}
	//如果没有其他进程创建这个信号灯，则重新创建
	if(!hSemaHandle){
		hSemaHandle = CreateSemaphore(NULL, MAX_SEMACOUNT, MAX_SEMACOUNT, NULL);//"SQLSema");
	}
	if(hSemaHandle==NULL){ //无法创建信号量
		free(strSQL);
		delete pSQLData;
		InterlockedDecrement(&giSqlThreadCount);
		return 1;
	}
	WaitForSingleObject(hSemaHandle,60000);

	//if(g_DisconnectDB && giConnCount>=MaxConnCount-1)
	//{
	//	DWORD d=GetTickCount();
	//	while( (GetTickCount()-d<=32000) && g_DisconnectDB )
	//	{
	//		Sleep(1000);
	//	}
	//	CString s;
	//	s.Format("等待数据库连接成功，耗时:%d ms 连接状态:%d",GetTickCount()-d,g_DisconnectDB);
	//	pFrame->WriteInfoFile(s);
	//}
	//LARGE_INTEGER litmp; 
	//double	dFreq = 0.0;
	//QueryPerformanceFrequency(&litmp);
	//dFreq=(double)litmp.QuadPart;// 获得计数器的时钟频率
	//LARGE_INTEGER   timedata1; 
	//LARGE_INTEGER   timedata2; 
	//::QueryPerformanceCounter(&timedata1); 
	//DWORD dw=GetTickCount();
	//bool bNewConn;
	//bNewConn=false;
	//_ConnectionPtr pConn;
	//pConn = NULL;
	//try
	//{
	//	InterlockedIncrement(&giSqlCount);
	//	if( giConnCount<MaxConnCount )
	//	{
	//		bNewConn=true;
	//		InterlockedIncrement(&giConnCount);
	//		pConn.CreateInstance(__uuidof(Connection));
	//		if(pConn)
	//		{
	//			pConn->ConnectionTimeout = 10;
	//			pConn->CommandTimeout = 180;//90;
	//			pConn->Open(_bstr_t(theApp.m_ConnectStr),_T(""),_T(""),adModeUnknown);
	//			pConn->Execute("SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED",NULL,adCmdText);
	//			pConn->Execute(strSQL,NULL,adCmdText);

	//			if (pConn->State & adStateOpen)
	//				pConn->Close();
	//			pConn.Release();
	//			pConn=NULL;
	//		}
	//		InterlockedDecrement(&giConnCount);

	//	}
	//	else
	//	{
	//		bNewConn=false;
	//		theApp.m_pConn->Execute(strSQL,NULL,adCmdText);
	//	}
	//	::QueryPerformanceCounter(&timedata2); 
	//	//(double)(timedata2.QuadPart-timedata1.QuadPart)/3600   ms
	//	LONG dwOk=(double)(timedata2.QuadPart-timedata1.QuadPart)/dFreq*10000;//GetTickCount()-dw;
	//	InterlockedExchangeAdd(&gSqlTimes, dwOk);
	//	InterlockedIncrement(&giAllSqlCount);
	//	InterlockedDecrement(&giSqlCount);

	//	if(RepeatTimes>0)
	//	{
	//		//pFrame->WriteInfoFile("重试写入数据库成功");
	//	}
	//}
	//catch(_com_error e)
	//{
	//	if(bNewConn){
	//		InterlockedDecrement(&giConnCount);
	//		if (pConn->State & adStateOpen)
	//			pConn->Close();
	//		pConn.Release();
	//		pConn=NULL;
	//	}

	//	InterlockedDecrement(&giSqlCount);
	//	LONG dwOk=(double)(timedata2.QuadPart-timedata1.QuadPart)/dFreq*10000;//GetTickCount()-dw;
	//	InterlockedExchangeAdd(&gSqlTimes, dwOk);
	//	InterlockedIncrement(&giAllSqlCount);
	//	//?err
	//	//CString s;
	//	//s.Format("%08lx",e.Error());
	//	//g_LastDBErrorTime=COleDateTime::GetCurrentTime();

	//	if(s=="80004005")
	//	{
	//		//g_DisconnectDB=TRUE;
	//		//g_LastDisconnectTime=COleDateTime::GetCurrentTime();
	//		//pFrame->ShowAppMessage("数据库已经断开。");
	//	}
	//	if((RepeatTimes<2) && (e.Error()!=0x80040e2f) )//重试次数小于1次的，继续重试  ; 0x80040e2f(插入重复键)
	//	{
	//		//CString strTemp;
	//		//strTemp.Format(_T("执行SQL语句产生错误，等待后重试。\r\n\t错误信息:%s\r\n\t错误描述:%s\r\n\t源      :%s 错误号:%s"),e.ErrorMessage(),(LPCTSTR)_bstr_t(e.Description()),(LPCTSTR)_bstr_t(e.Source()),s);
	//		//pFrame->ShowAppMessage(strTemp);

	//		//if(pFrame->m_bSaveSQL)//Add
	//		//{
	//		//	strTemp.Format("--err:%s",(LPCTSTR)_bstr_t(e.Description()));
	//		//	pFrame->WriteSQLText(strTemp,false);//?del
	//		//	pFrame->WriteSQLText(strSQL,false);
	//		//	pFrame->WriteSQLText("--end",false);
	//		//}
	//		//pSQLData->nRepeatTimes++;
	//		//::AfxBeginThread(_ExecSql, (LPVOID)pSQLData);//写入数据库
	//		//ReleaseSemaphore(hSemaHandle,1,NULL);
	//		//InterlockedDecrement(&giSqlThreadCount);
	//		return 0;
	//	}
	//	else//否则不再重试
	//	{
	//		//CString strTemp;
	//		//strTemp.Format(_T("连续无法写入数据库，不再重试。\r\n\t错误信息:%s\r\n\t错误描述:%s\r\n\t源      :%s 错误号:%s"),e.ErrorMessage(),(LPCTSTR)_bstr_t(e.Description()),(LPCTSTR)_bstr_t(e.Source()),s);
	//		//pFrame->ShowAppMessage(strTemp);

	//		//if(e.Error()!=0x80040e2f)// 0x80040e2f(插入重复键)
	//		//{
	//		//	pFrame->WriteInfoFile(strSQL);

	//		//	pFrame->WriteSQLText("--无法写入数据库",false);
	//		//	pFrame->WriteSQLText(strSQL,false);
	//		//}
	//		free(strSQL);
	//		delete pSQLData;
	//		ReleaseSemaphore(hSemaHandle,1,NULL);
	//		InterlockedDecrement(&giSqlThreadCount);
	//		return 1;
	//	}
	//}
	////if(pFrame->m_bSaveSQL)
	////{
	////	CString s;
	////	s.Format("%d %d %s",giAllSqlCount,giSqlThreadCount,strSQL);
	////	pFrame->WriteSQLText(s,false);
	////}
	//free(strSQL);
	//delete pSQLData;
	//LONG lPreCount=MAX_SEMACOUNT;
	//ReleaseSemaphore(hSemaHandle,1,&lPreCount);
	//InterlockedDecrement(&giSqlThreadCount);
	return 0;
}

UINT _thread_timer(LPVOID lparam)
{
	CYAServerDlg* dlg = reinterpret_cast<CYAServerDlg*>(lparam);
	while(!g_exit){
		ULONGLONG cur_time =::GetTickCount();
		//case TMR_SYNC_READER_TIME:
		//	{
		//		send_sync_reader();
		//		break;
		//	}
		//case TMR_CLEAR_CALL_TIMER:
		//	{
		//		clear_call_info();
		//		break;
		//	}
		//case TMR_SEND_CALL:
		//	{
		//		send_call_info();
		//		break;
		//	}
		// send_json_counting
		//if(cur_time - time_send_json_counting > theApp.send_json_counting ){
		//	dlg->send_json_data(JSON_CMD_VALUE_PUSH, dlg->get_json_counting());
		//	time_send_json_counting = ::GetTickCount();
		//}
		//// send_json_alarm
		//if(cur_time - time_send_json_alarm > theApp.send_json_alarm){
		//	dlg->send_json_data(JSON_CMD_VALUE_PUSH, dlg->get_json_alarm());
		//	time_send_json_alarm = ::GetTickCount();
		//}
		//// send_json_device
		//if(cur_time - time_send_json_device_state > theApp.send_json_alarm){
		//	dlg->deal_readers();
		//	dlg->send_json_data(JSON_CMD_VALUE_PUSH, dlg->get_json_device_state());
		//	time_send_json_device_state = ::GetTickCount();
		//}
		// send_json_postion
		if(cur_time - time_send_json_postion > theApp.send_json_postion){			
			dlg->package_data();
			time_send_json_postion = ::GetTickCount();
		}
		WaitForMS(10);
	}
	return 0;
}

UINT _thread_monitor(LPVOID lparam)
{
	CYAServerDlg* dlg = reinterpret_cast<CYAServerDlg*>(lparam);
	time_t time_end = time(NULL);
	while (!g_exit){
		time_t time_current = time(NULL);
		// 判断采集状态， 20s没有接收到数据认为采集中断 
		dlg->is_server_ok = (difftime(time_current, dlg->m_time_last_rec) > 20) ? false : true;
		dlg->set_run_state(); // 更新采集运行状态

		if(!IsWindow(theApp.m_hwnd_monitor)){ // 监控程序没有打开
			theApp.m_hwnd_monitor = NULL;
			//// 启动监控程序
			//if(strlen(theApp.m_path_monitor)<=0){
			//	strcpy(theApp.m_path_monitor, "YAMonitor.exe");//启动同目录下的monitor
			//}
			//WinExec(theApp.m_path_monitor, SW_HIDE);
		}
		// 发送给监控程序
		if(theApp.m_hwnd_monitor && dlg->m_bListen){
			WPARAM wpSERVERSTATE=WPARAM(dlg->m_uint_state);
			::PostMessage(theApp.m_hwnd_monitor, WM_ON_MONITOR, wpSERVERSTATE, LPARAM(dlg->m_hWnd));
		}
		WaitForS(10);
	}
	return 0;
}

BOOL CYAServerDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();

	// 将“关于...”菜单项添加到系统菜单中。

	// IDM_ABOUTBOX 必须在系统命令范围内。
	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);

	CMenu* pSysMenu = GetSystemMenu(FALSE);
	if (pSysMenu != NULL)
	{
		BOOL bNameValid;
		CString strAboutMenu;
		bNameValid = strAboutMenu.LoadString(IDS_ABOUTBOX);
		ASSERT(bNameValid);
		if (!strAboutMenu.IsEmpty())
		{
			pSysMenu->AppendMenu(MF_SEPARATOR);
			pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
		}
	}
	// 设置此对话框的图标。当应用程序主窗口不是对话框时，框架将自动
	// 执行此操作
	SetIcon(m_hIcon, TRUE);			// 设置大图标
	SetIcon(m_hIcon, FALSE);		// 设置小图标

	init_param();
	init_ui();

	init_base_data();
	load_his_data();

	//ReceiveDateTime=COleDateTime::GetCurrentTime();
	theApp.set_server_handle(this->m_hWnd);	
	theApp.load_monitor_conf();
	m_thread_monitor = ::AfxBeginThread(_thread_monitor, this, THREAD_PRIORITY_HIGHEST);

	RECT rc;
	GetWindowRect(&rc);
	rc.left=rc.right;
	rc.right+=250;

	//创建菜单
	m_mnMain.LoadMenu(IDR_MENUMAIN);
	SetMenu(&m_mnMain);
	CString strInfo;

	//SetTimer(RELOADCARD_TIMER,RELOADCARD_INTERVAL,0);
	//SetTimer(WRITE_LASTTIME,theApp.LastTimeInterval,0);
	//// 将图标放入系统托盘
	//nd.cbSize	= sizeof (NOTIFYICONDATA);
	//nd.hWnd	= m_hWnd;
	//nd.uID	= IDI_ICON;
	//nd.uFlags	= NIF_ICON|NIF_MESSAGE|NIF_TIP;
	//nd.uCallbackMessage= WM_NOTIFYICON;
	//nd.hIcon	= m_hIcon;

	//strcpy(nd.szTip, "采集应用服务器");
	//Shell_NotifyIcon(NIM_ADD, &nd);
	SetWindowText(_T("永安信通数据采集系统"));
	//OnBnStart();

	time_send_json_counting = time_send_json_device_state=time_send_json_alarm=time_send_json_postion=::GetTickCount();
	time_sync_reader_time=time_clear_call_time=time_send_call=::GetTickCount();
	m_thread_timer = ::AfxBeginThread(_thread_timer, this, THREAD_PRIORITY_HIGHEST);

	UpdateData(FALSE);
	return TRUE;  // 除非将焦点设置到控件，否则返回 TRUE
}

void CYAServerDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else
	{
		CDialogEx::OnSysCommand(nID, lParam);
	}
}

// 如果向对话框添加最小化按钮，则需要下面的代码
//  来绘制该图标。对于使用文档/视图模型的 MFC 应用程序，
//  这将由框架自动完成。

void CYAServerDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); // 用于绘制的设备上下文or

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		// 使图标在工作区矩形中居中
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// 绘制图标
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialogEx::OnPaint();
	}
}

//当用户拖动最小化窗口时系统调用此函数取得光标
//显示。
HCURSOR CYAServerDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}

void CYAServerDlg::OnBnStart()
{
	//Test();

	if(!is_websocket_login){
		ws_login();
	}
	start_tcp_server();
}

void CYAServerDlg::OnBnStop()
{
	//if(MessageBoxEx(m_hWnd, _T("确定停止吗？"), _T("询问"), MB_ICONQUESTION|MB_OKCANCEL|MB_DEFBUTTON2,NULL) == IDCANCEL){
	//	return;
	//}
	stop_tcp_server();
	//stop_timer();
}

LRESULT CYAServerDlg::on_monitor( WPARAM wParam, LPARAM lParam )
{
	if(m_bListen){
		m_uint_state = wParam ;
	}
	if(wParam == 0xFFFF){
		stop_and_exit();
	}
	return S_OK;
}

void CYAServerDlg::init_ui()
{
	set_app_state(ST_STOPPED);
	m_listctrl_reader.SetColumnHeader(_T("分站号,60;分站地址,120;状态,60;"));
	m_listctrl_reader.SetGridLines(TRUE);
	m_listctrl_reader.SetEditable(FALSE);
	m_listctrl_reader.SetSortable(FALSE);

	Invalidate(FALSE);
}

void CYAServerDlg::set_app_state( EnAppState eas )
{
	m_enState = eas;

	if(this->GetSafeHwnd() == nullptr)
		return;

	m_btStart.EnableWindow(m_enState == ST_STOPPED);
	m_btStop.EnableWindow(m_enState == ST_STARTED);
	//m_Close.EnableWindow(m_enState == ST_STARTED);
	//m_SycnTime.EnableWindow(m_enState == ST_STARTED);
	//m_HistoryData.EnableWindow(m_enState == ST_STARTED);
}

void CYAServerDlg::init_param()
{
	::SetMainWnd(this);
	::SetInfoList(&m_list_log);
	dw_last_send_time = GetTickCount();
	m_time_last_rec = time(NULL);

	m_bListen = FALSE;
	m_nPort = PORT_SERVER_MASTER;
	m_nCountClick = 0;
	m_ws_url = TEST_WS_URL;

	time_over_count_person = time_over_count_vehicle = 0;
	is_server_ok = true;
	g_exit = false;

	InitializeCriticalSection(&m_csWriteLog);
	InitializeCriticalSection(&m_csRemoveSocket);

	//down_mine_count.count_vehicle = 0;
	//down_mine_count.count_person = 0;
	//down_mine_count.count_total = 0;

	//Anc1 = new Point2[3];
	//Anc1[0].x = 178;
	//Anc1[0].y = 182; 
	//Anc1[1].x = Anc1[1].y = 650;
	//Anc1[2].x = 995;
	//Anc1[2].y = 190;

	//Anc1[0].x = 1.30;
	//Anc1[0].y = 1.77;
	//Anc1[1].x = 5.53;
	//Anc1[1].y = 5.36;
	//Anc1[2].x = 8.63;
	//Anc1[2].y = 1.60;
	//double x[3] = {1.18, 5.6, 8.61}; // 坐标
	//double y[3] = {1.58, 5.42, 1.52}; // 坐标
	//cal_locate.setAnchors(Anc1);

	//从配置中读取(regedit)
	load_param_from_ini();
	database_connect();
	ws_open();	
	//UpdateData(FALSE);
}

void CYAServerDlg::stop_and_exit()
{
	stop_tcp_server();
	//set_button_state(TRUE);
	ws_close();

	//m_listctrl_reader.DeleteAllItems();

	//if(m_bIsInit) //停止定时器(停止呼叫、通行侦测)		
	//	::KillTimer(NULL, CLEAR_CALL_TIMER);
	//::KillTimer(NULL, CLEAR_PASS_TIMER);
	//{
	//	//m_Comm.Stop(1);
	//	//?m_Comm

	//	ShowAppMessage("停止采集数据");

	//	READER_EX_INFO *pCurReaderEx;
	//	for(int i=0;i<MaxMineID;i++)
	//		for(int j=1;j<MAXREADERCOUNT;j++)
	//		{
	//			pCurReaderEx=AllReaderData[j][i];
	//			if(pCurReaderEx==NULL)//没有该分站
	//				continue;
	//			SaveReaderData(i,pCurReaderEx);//停止服务
	//		}

	//		//停止监听
	//		m_bIsInit = FALSE;
	//}
	//if(m_bListen)
	//{
	//	ClearListener();
	//	ShowAppMessage("停止监听\n");
	//	m_bListen=FALSE;
	//}
	g_exit = true;
	if(m_thread_monitor){
		WaitForSingleObject(m_thread_monitor->m_hThread,INFINITE);
	}
	m_thread_monitor = NULL;
	if(m_thread_timer){
		WaitForSingleObject(m_thread_timer->m_hThread, INFINITE);
	}
	m_thread_timer = NULL;
	DeleteCriticalSection(&m_csWriteLog);
	DeleteCriticalSection(&m_csRemoveSocket);
}

void CYAServerDlg::set_run_state()
{
	m_uint_state = 0;
	if(!is_server_ok){
		m_uint_state |= 0x10; // 长时间未接收到采集数据（网络故障，采集故障）
	}

	//m_uKJ133State=0;
	//UINT uNoClient=0x0002;
	//UINT uClientError=0;
	//for(POSITION pos = m_connectionList.GetHeadPosition(); pos != NULL;)
	//{
	//	CClientSocket* pSocket = (CClientSocket*)m_connectionList.GetNext(pos);
	//	uNoClient=0;
	//	if(pSocket->bError)
	//		uClientError=0x0004;
	//}
	//m_uKJ133State |= uNoClient;
	//m_uKJ133State |= uClientError;

	//m_uKJ133State |= (m_bListen?0:0x0001);
	//m_uKJ133State |= uReaderError;
	//m_uKJ133State |= iMo;//0x0010,采集数据出问题 0x0000，没问题
	//if(g_DisconnectDB)
	//	m_uKJ133State |=0x0100;

	//UINT uDBError=0;
	//UINT uDisconnect=0;
	//COleDateTime nowTime=COleDateTime::GetCurrentTime();
	//COleDateTimeSpan spDateTime;
	//spDateTime.SetDateTimeSpan(0,1,0,0);
	//if(g_LastDBErrorTime + spDateTime > nowTime)
	//	uDBError=0x0200;
	//if(g_LastDisconnectTime + spDateTime > nowTime)
	//	uDisconnect=0x0400;
	//m_uKJ133State |= uDBError;
	//m_uKJ133State |= uDisconnect;
}

int CYAServerDlg::init_staffer(string staff_id /* = "" */, bool is_card /*= false*/ )
{
	CMysqlConn* pConn = NULL;
	CDBConnGuard pDbGuard(pConn);
	MYSQL_RES* pRes;
	MYSQL_ROW pRow;
	int err = 0;
	char buf[LENGTH_SQL] = {0};
	if(staff_id.length() == 0){
		sprintf_s(buf, "SELECT staff_id, s.card_id, c.card_type_id, s.name, \
					   s.dept_id, s.group_id, s.occupation_id, \
					   d.name as dname, g.name as gname, o.name as oname \
					   FROM dat_staff s \
					   LEFT JOIN dat_card c ON s.card_id = c.card_id \
					   LEFT JOIN dat_dept d ON s.dept_id = d.dept_id \
					   LEFT JOIN dat_group g ON s.group_id = g.group_id \
					   LEFT JOIN dat_occupation o ON s.occupation_id = o.occupation_id \
					   WHERE c.card_type_id = 1 and s.state = 0;");
	}else if(is_card){
		sprintf_s(buf, "SELECT staff_id, s.card_id, c.card_type_id, s.name, \
					   s.dept_id, s.group_id, s.occupation_id, \
					   d.name as dname, g.name as gname, o.name as oname \
					   FROM dat_staff s \
					   LEFT JOIN dat_card c ON s.card_id = c.card_id \
					   LEFT JOIN dat_dept d ON s.dept_id = d.dept_id \
					   LEFT JOIN dat_group g ON s.group_id = g.group_id \
					   LEFT JOIN dat_occupation o ON s.occupation_id = o.occupation_id \
					   WHERE c.card_type_id = 1 and s.state = 0 AND s.card_id = '%s';", staff_id.c_str());
	}else{
		sprintf_s(buf, "SELECT staff_id, s.card_id, c.card_type_id, s.name, \
					   s.dept_id, s.group_id, s.occupation_id, \
					   d.name as dname, g.name as gname, o.name as oname \
					   FROM dat_staff s \
					   LEFT JOIN dat_card c ON s.card_id = c.card_id \
					   LEFT JOIN dat_dept d ON s.dept_id = d.dept_id \
					   LEFT JOIN dat_group g ON s.group_id = g.group_id \
					   LEFT JOIN dat_occupation o ON s.occupation_id = o.occupation_id \
					   WHERE c.card_type_id = 1 and s.state = 0 AND staffer_id = '%s';", staff_id.c_str());
	}

	pRes = pConn->Execute(buf, err);
	Card* pCard = NULL;
	int nRow = 0;
	while(pRow = mysql_fetch_row(pRes))	{
		CardMap::iterator it = mp_card_list_all.find(pRow[1]);
		if(it != mp_card_list_all.end()){
			pCard = it->second;
		}else{
			pCard = new Card(pRow[1], atoi(pRow[2]), theApp.z_offset);
			mp_card_list_all.insert(make_pair(pCard->card_id, pCard));
			nRow++;
		}
		pCard->id = pRow[0];
		pCard->name = pRow[3];
		pCard->dept_id = atoi(pRow[4]);
		pCard->group_id = atoi(pRow[5]);
		pCard->department = pRow[7];
		pCard->group = pRow[8];
		pCard->occupation = pRow[9];
	}
	mysql_free_result(pRes);
	CString strlog;
	strlog.Format(_T("%s%d%s"), _T(LOG_INIT_STAFF), nRow, _T(LOG_RECORD_COUNT));
	show_log(strlog);
	return 0;
}

int CYAServerDlg::init_vehicle(string vehicle_id /* = "" */, bool is_card /*= false*/)
{
	CMysqlConn* pConn = NULL;
	CDBConnGuard pDbGuard(pConn);
	MYSQL_RES* pRes;
	MYSQL_ROW pRow;
	int err = 0;
	char buf[LENGTH_SQL] = {0};
	if(vehicle_id.length() == 0){
		sprintf_s(buf, "SELECT vehicle_id, v.card_id, c.card_type_id, v.name, v.number, \
					   v.dept_id, v.group_id, v.vehicle_type_id, \
					   d.name as dname, g.name as gname, vt.name as vtname \
					   FROM dat_vehicle v \
					   LEFT JOIN dat_card c ON v.card_id = c.card_id \
					   LEFT JOIN dat_dept d ON v.dept_id = d.dept_id \
					   LEFT JOIN dat_group g ON v.group_id = g.group_id \
					   LEFT JOIN dat_vehicle_type vt ON v.vehicle_type_id = vt.vehicle_type_id \
					   WHERE c.card_type_id = 2 and v.state = 0;");
	}else if(is_card){
		sprintf_s(buf, "SELECT vehicle_id, v.card_id, c.card_type_id, v.name, v.number, \
					   v.dept_id, v.group_id, v.vehicle_type_id, \
					   d.name as dname, g.name as gname, vt.name as vtname \
					   FROM dat_vehicle v \
					   LEFT JOIN dat_card c ON v.card_id = c.card_id \
					   LEFT JOIN dat_dept d ON v.dept_id = d.dept_id \
					   LEFT JOIN dat_group g ON v.group_id = g.group_id \
					   LEFT JOIN dat_vehicle_type vt ON v.vehicle_type_id = vt.vehicle_type_id \
					   WHERE c.card_type_id = 2 and v.state = 0 AND v.card_id ='%s';", vehicle_id.c_str());
	}else{
		sprintf_s(buf, "SELECT vehicle_id, v.card_id, c.card_type_id, v.name, v.number, \
					   v.dept_id, v.group_id, v.vehicle_type_id, \
					   d.name as dname, g.name as gname, vt.name as vtname \
					   FROM dat_vehicle v \
					   LEFT JOIN dat_card c ON v.card_id = c.card_id \
					   LEFT JOIN dat_dept d ON v.dept_id = d.dept_id \
					   LEFT JOIN dat_group g ON v.group_id = g.group_id \
					   LEFT JOIN dat_vehicle_type vt ON v.vehicle_type_id = vt.vehicle_type_id \
					   WHERE c.card_type_id = 2 and v.state = 0 AND vehicle_id='%s';", vehicle_id.c_str());
	}
	pRes = pConn->Execute(buf, err);
	Card* pCard = NULL;
	int nRow = 0;
	while(pRow = mysql_fetch_row(pRes)){
		CardMap::iterator it = mp_card_list_all.find(pRow[1]);
		if(it != mp_card_list_all.end()){
			pCard = it->second;
		}else{
			pCard = new Card(pRow[1], atoi(pRow[2]), theApp.z_offset);
			mp_card_list_all.insert(make_pair(pCard->card_id, pCard));
			nRow++;
		}
		pCard->id = (pRow[0] == NULL) ? "" : pRow[0];
		pCard->name = (pRow[3] == NULL) ? "" : pRow[3];
		pCard->number = (pRow[4] == NULL) ? "" : pRow[4];
		pCard->dept_id = atoi(pRow[5]);
		pCard->group_id = atoi(pRow[6]);
		pCard->department = (pRow[8] == NULL) ? "" : pRow[8];
		pCard->group = (pRow[9] == NULL) ? "" : pRow[9];
		pCard->worktype = (pRow[10] == NULL) ? "" : pRow[10];
	}
	mysql_free_result(pRes);
	CString strlog;
	strlog.Format(_T("%s%d%s"), _T(LOG_INIT_VEHICLE), nRow, _T(LOG_RECORD_COUNT));
	show_log(strlog);
	return 0;
}

int CYAServerDlg::init_map(int map_id /*= 0*/)
{
	CMysqlConn* pConn = NULL;
	CDBConnGuard pDbGuard(pConn);
	MYSQL_ROW pRow;
	MYSQL_RES *pRes = NULL;
	int err = 0;
	char strsql[LENGTH_SQL] = {0};	
	if(map_id == 0){
		sprintf_s(strsql, "SELECT map_id, name, scale FROM dat_map;");
	}else{
		sprintf_s(strsql, "SELECT map_id, name, scale FROM dat_map WHERE map_id = %d; ", map_id);
	}
	pRes = pConn->Execute(strsql, err);

	MapInfo* pMap = NULL;
	int nRow = 0;
	while(pRow = mysql_fetch_row(pRes)){
		MapInfoMap::iterator it = mp_map_list.find(atoi(pRow[0]));
		if(it != mp_map_list.end()){
			pMap = it->second;
		}else{
			pMap = new MapInfo();
			pMap->map_id = atoi(pRow[0]);
			mp_map_list.insert(make_pair(pMap->map_id, pMap));
			nRow++;
		}
		pMap->map_name = pRow[1];
		pMap->map_scale = atof(pRow[2]);
	}
	mysql_free_result(pRes);
	CString strlog;
	strlog.Format(_T("%s%d%s"), _T(LOG_INIT_MAP), nRow, _T(LOG_RECORD_COUNT));
	show_log(strlog);

	return 0;
}

int CYAServerDlg::init_area(int area_id /* = 0 */)
{
	CMysqlConn* pConn = NULL;
	CDBConnGuard pDbGuard(pConn);
	MYSQL_ROW pRow;
	MYSQL_RES *pRes = NULL;
	int err = 0;
	char strsql[LENGTH_SQL] = {0};	
	if(area_id == 0){
		sprintf_s(strsql, "SELECT area_id, name, map_id, area_type_id, path, \
						  over_count_person, over_count_vehicle, over_time_person, over_time_vehicle \
						  FROM dat_area;");
	}else{
		sprintf_s(strsql, "SELECT area_id, name, map_id, area_type_id, path, \
						  over_count_person, over_count_vehicle, over_time_person, over_time_vehicle \
						  FROM dat_area WHERE area_id = %d; ", area_id);
	}
	pRes = pConn->Execute(strsql, err);
	Area* pArea = NULL;
	int nRow = 0;
	while(pRow = mysql_fetch_row(pRes)){
		AreaMap::iterator it = mp_area_list.find(atoi(pRow[0]));		
		if(it != mp_area_list.end()){
			pArea = it->second;
		}else{
			pArea = new Area();
			pArea->area_id = atoi(pRow[0]);
			mp_area_list.insert(make_pair(pArea->area_id, pArea));
			nRow++;
		}

		pArea->map_id = atoi(pRow[2]);
		MapInfoMap::iterator map_it = mp_map_list.find(pArea->map_id);
		if(map_it != mp_map_list.end()){
			AreaMap::iterator area_it = map_it->second->map_area_list.find(pArea->area_id);
			if(area_it == map_it->second->map_area_list.end()){
				map_it->second->map_area_list.insert(make_pair(pArea->area_id, pArea));
			}
		}

		pArea->area_name = pRow[1];
		pArea->area_type_id = atoi(pRow[3]);
		pArea->path = pRow[4]; // 多边形
		pArea->over_count_person = atoi(pRow[5]);
		pArea->over_count_vehicle = atoi(pRow[6]);
		pArea->over_time_person = atoi(pRow[7]);
		pArea->under_time_vehicle = atoi(pRow[8]);
		pArea->init_border(pRow[4]);
		//pArea->x1 = atof(pRow[8]);
		//pArea->y1 = atof(pRow[9]);
		//pArea->z1 = atof(pRow[10]);
		//pArea->sr = atof(pRow[11]);
	}
	mysql_free_result(pRes);
	CString strlog;
	strlog.Format(_T("%s%d%s"), _T(LOG_INIT_AREA), nRow, _T(LOG_RECORD_COUNT));
	show_log(strlog);
	return 0;
}

int CYAServerDlg::init_reader(int reader_id /* = 0 */)
{
	// 从数据库中读取
	CMysqlConn* pConn = NULL;
	CDBConnGuard pDbGuard(pConn);
	MYSQL_ROW pRow;
	MYSQL_RES *pRes = NULL;
	int err = 0;
	char strsql[LENGTH_SQL] = {0};	
	if(reader_id == 0){
		sprintf_s(strsql, "SELECT reader_id, map_id, area_id, name, x, y, z, angle, \
						  state, ip, device_type_id, reader_type_id \
						  FROM dat_reader WHERE state=0;");
	}else{
		sprintf_s(strsql, "SELECT reader_id, map_id, area_id, name, x, y, z, angle, \
						  state, ip, device_type_id, reader_type_id \
						  FROM dat_reader WHERE state=0 AND reader_id = %d; ", reader_id);
	}
	pRes = pConn->Execute(strsql, err);

	Reader* pReader = NULL;
	int nRow = 0;;
	while(pRow = mysql_fetch_row(pRes))	{
		ReaderMap::iterator it = mp_reader_list.find(atoi(pRow[0]));		
		if(it != mp_reader_list.end()){
			pReader = it->second;
		}else{
			pReader = new Reader();
			pReader->reader_id = atoi(pRow[0]);
			mp_reader_list.insert(make_pair(pReader->reader_id, pReader));
			nRow++;
		}

		pReader->map_id = atoi(pRow[1]);
		MapInfoMap::iterator map_it = mp_map_list.find(pReader->map_id);
		if(map_it != mp_map_list.end()){
			ReaderMap::iterator reader_it = map_it->second->map_reader_list.find(pReader->reader_id);
			if(reader_it == map_it->second->map_reader_list.end()){
				map_it->second->map_reader_list.insert(make_pair(pReader->reader_id, pReader));
			}
			pReader->map_scale = map_it->second->map_scale;
		}
		pReader->area_id = atoi(pRow[2]);
		pReader->reader_name = pRow[3];
		pReader->reader_x = atof(pRow[4]);
		pReader->reader_y = atof(pRow[5]);
		pReader->reader_z = atof(pRow[6]);
		pReader->reader_angle = atof(pRow[7]) * M_PI /180;
		pReader->ip = pRow[9];
		pReader->device_type_id = atoi(pRow[10]);
		pReader->pos_state = atoi(pRow[11]);
	}
	mysql_free_result(pRes);
	CString strlog;
	strlog.Format(_T("%s%d%s"), _T(LOG_INIT_READER), nRow, _T(LOG_RECORD_COUNT));
	show_log(strlog);
	return 0;
}

int CYAServerDlg::init_antenna(int reader_id /* = 0 */)
{
	CMysqlConn* pConn = NULL;
	CDBConnGuard pDbGuard(pConn);
	MYSQL_ROW pRow;
	MYSQL_RES *pRes = NULL;
	int err = 0;
	char strsql[LENGTH_SQL] = {0};	
	if(reader_id == 0){
		sprintf_s(strsql, "SELECT antenna_id, a.reader_id, reader_idx, a.x, a.y, a.z, a.angle \
						  FROM dat_antenna a, dat_reader r \
						  WHERE a.reader_id = r.reader_id;");
	}else{
		sprintf_s(strsql, "SELECT antenna_id, a.reader_id, reader_idx, a.x, a.y, a.z, a.angle \
						  FROM dat_antenna a, dat_reader r \
						  WHERE a.reader_id = r.reader_id AND reader_id = %d; ", reader_id);
	}
	pRes = pConn->Execute(strsql,err);
	int nRow = 0;
	while(pRow = mysql_fetch_row(pRes)){
		ReaderMap::iterator it = mp_reader_list.find(atoi(pRow[1]));
		if(it != mp_reader_list.end()){
			Antenna* ant = new Antenna();
			ant->antenna_id = atoi(pRow[0]);
			ant->antenna_x = atof(pRow[3]);
			ant->antenna_y = atof(pRow[4]);
			ant->antenna_z = atof(pRow[5]);
			ant->antenna_angle = atof(pRow[6]) * M_PI / 180.0;
			int idx = (atoi(pRow[2]) == 1) ? 0 : 1;			
			it->second->ant[idx] = ant;
			nRow++;
		}
	}
	mysql_free_result(pRes);
	CString strlog;
	strlog.Format(_T("%s%d%s"), _T(LOG_INIT_ANTENNA), nRow, _T(LOG_RECORD_COUNT));
	show_log(strlog);
	return 0;
}

int CYAServerDlg::init_dev_adhoc( int reader_id /*= 0*/ )
{
	CMysqlConn* pConn = NULL;
	CDBConnGuard pDbGuard(pConn);
	MYSQL_ROW pRow;
	MYSQL_RES *pRes = NULL;
	int err = 0;
	char strsql[LENGTH_SQL] = {0};	
	if(reader_id == 0){
		sprintf_s(strsql, "select ad.adhoc_id, ad.reader_id, ad.idx, ad.x, ad.y, ad.z from dat_dev_adhoc ad, dat_reader r \
						  where ad.reader_id = r.reader_id;");
	}else{
		sprintf_s(strsql, "select ad.adhoc_id, ad.reader_id, ad.idx, ad.x, ad.y, ad.z from dat_dev_adhoc ad, dat_reader r \
						  where ad.reader_id = r.reader_id and ad.reader_id = %d; ", reader_id);
	}
	pRes = pConn->Execute(strsql,err);
	int nRow = 0;
	int idx = 0;
	while(pRow = mysql_fetch_row(pRes)){
		ReaderMap::iterator it = mp_reader_list.find(atoi(pRow[1]));
		if(it != mp_reader_list.end()){
			Adhoc* adhoc = new Adhoc();
			adhoc->adhoc_id = atoi(pRow[0]);
			adhoc->idx = atoi(pRow[2]);
			adhoc->x = atof(pRow[3]);
			adhoc->y = atof(pRow[4]);
			adhoc->z = atof(pRow[5]);
			idx = (adhoc->idx < ADHOC_COUNT)?adhoc->idx:0;
			it->second->adhoc[idx] = adhoc;
			nRow++;
		}
	}
	mysql_free_result(pRes);
	CString strlog;
	strlog.Format(_T("%s%d%s"), _T(LOG_INIT_ADHOC), nRow, _T(LOG_RECORD_COUNT));
	show_log(strlog);
	return 0;
}

/*
* 函数名：init_all_readers_coverage
* 从数据库的dat_reader_path表中读取指定map_id和reader_id的地图范围集，
* 将此分站的地图范围集保存在分站类中的readerCoverage中；
* 如果指定了相同的地图范围集的reader_id,则直接将指定的reader_id的地图范围集赋值给此reader_id的地图范围集
* 然后将地图集赋值给station
* 
*
* @param
*		reader_id		分站id号
*
* @return
*		-1，表示在分站map中未找到此分站信息或者未正常执行；0，表示正常执行
*
*/
int CYAServerDlg::init_all_readers_coverage(int reader_id)
{
	CMysqlConn* pConn = NULL;
	CDBConnGuard pDbGuard(pConn);

	//如果无可用数据库连接，不执行后续操作
	if(pConn == NULL){
		return -1;
	}

	char sql[LENGTH_SQL] = {0};
	if(reader_id == 0){
		sprintf_s(sql, "select p.same_config_reader,p.reader_id,p.idx,p.x,p.y,p.z,p.is_bezier from dat_reader_path_17 p ,dat_reader r where p.reader_id = r.reader_id;");
	}else{
		sprintf_s(sql, "select same_config_reader,reader_id,idx,x,y,z,is_bezier from dat_reader_path_17 where reader_id = %d; ", reader_id);
	}

	MYSQL_RES* pRes = NULL;
	MYSQL_ROW pRow;
	int err = 0;
	int nRow = 0;
	//查询数据库
	pRes = pConn->Execute(sql,err);

	//从数据库获得信息赋给分站对象的地图集
	while(pRow = mysql_fetch_row(pRes)){
		int nReaderId = atoi(pRow[1]);
		ReaderMap::iterator it = mp_reader_list.find(nReaderId);

		int nSameConfigReader = atoi(pRow[0]);
		int nIdx = atoi(pRow[2]);
		//判断地图集信息是否可利用其它分站的覆盖范围，如果可用，则使用其它分站的覆盖范围
		//-1表示不可用，否则表示可复用分站id号为nSameConfigReader的地图集覆盖范围
		if(nSameConfigReader == -1){
			_point p;
			p.x = atof(pRow[3]);
			p.y = atof(pRow[4]);
			p.z = atof(pRow[5]);
			it->second->readerCoveragePath.insert(make_pair(nIdx,p));
			it->second->bIsInitCoverage = true;
			nRow++;
		}else{
			it->second->readerCoveragePath = mp_reader_list.find(nSameConfigReader)->second->readerCoveragePath;
			it->second->bIsInitCoverage = true;
			nRow++;
		}
	}
	mysql_free_result(pRes);

	//输出操作数据库的日志信息
	CString strlog;
	strlog.Format(_T("%s%d%s"), _T(LOG_INIT_VEHICLE), nRow, _T(LOG_RECORD_COUNT));
	show_log(strlog);

	//根据获得地图集将其赋给mp_reader_path_list
	ReaderMap::iterator it = mp_reader_list.begin();
	for(it;it!=mp_reader_list.end();it++){
		if(it->second->bIsInitCoverage){
			int nReaderId = it->second->reader_id - 1;

			double dMapScale = mp_map_list.find(it->second->map_id)->second->map_scale;

			ReaderPath* pReaderPath = NULL;
			ReaderPathMap::iterator prpIt = mp_reader_path_list.find(nReaderId);
			if(prpIt != mp_reader_path_list.end()){
				pReaderPath = prpIt->second;
			}else{
				pReaderPath = new ReaderPath();
				mp_reader_path_list.insert(make_pair(nReaderId,pReaderPath));
			}
			pReaderPath->nRealCalcPoints = it->second->readerCoveragePath.size();
			for(int i=0;i<2;i++){
				pReaderPath->x[i] = it->second->ant[i]->antenna_x*dMapScale;
				pReaderPath->y[i] = it->second->ant[i]->antenna_y*dMapScale;
				pReaderPath->z[i] = it->second->ant[i]->antenna_z*dMapScale;
			}

			for(size_t j = 1;j <= it->second->readerCoveragePath.size(); j++){
				pReaderPath->px[j - 1] = it->second->readerCoveragePath.find(j)->second.x*dMapScale;
				pReaderPath->py[j - 1] = it->second->readerCoveragePath.find(j)->second.y*dMapScale;
				pReaderPath->pz[j - 1] = it->second->readerCoveragePath.find(j)->second.z*dMapScale;
			}

			//以下对应与全局变量的数组形式的另一种实现
			//初始化 
			/*station[nReaderId].nRealCalcPoints = 0;
			for(int i=0;i<2;i++){
			station[nReaderId].x[i] = 0;
			station[nReaderId].y[i] = 0;
			station[nReaderId].z[i] = 0;
			}
			for(int i=0;i<MAX_CALC_POINTS;i++){
			station[nReaderId].px[i] = 0;
			station[nReaderId].py[i] = 0;
			station[nReaderId].pz[i] = 0;
			}

			//double dMapScale = mp_map_list.find(it->second->map_id)->second->map_scale;
			station[nReaderId].nRealCalcPoints = it->second->readerCoveragePath.size();
			for(int i=0;i<2;i++){
			station[nReaderId].x[i] = it->second->ant[i]->antenna_x*dMapScale;
			station[nReaderId].y[i] = it->second->ant[i]->antenna_y*dMapScale;
			station[nReaderId].z[i] = it->second->ant[i]->antenna_z*dMapScale;
			}

			for(size_t j = 1;j <= it->second->readerCoveragePath.size(); j++){
			station[nReaderId].px[j - 1] = it->second->readerCoveragePath.find(j)->second.x*dMapScale;
			station[nReaderId].py[j - 1] = it->second->readerCoveragePath.find(j)->second.y*dMapScale;
			station[nReaderId].pz[j - 1] = it->second->readerCoveragePath.find(j)->second.z*dMapScale;
			}*/
		}
	}

	return 0;
}

/*
* 函数名：init_tdoa_all_readers_coverage
* 实现初始化TDOA方式的地图集描述，并存储冗余数据
* 冗余数据的主要作用在于：例如存在分站<B1,B2>之间的地图集描述，那么也存在<B2,B1>的对应关系
*
* param 
*		reader_id	------	分站id号
*
* return
*		如果执行失败返回-1
*		正确执行，返回0
*
*/
int CYAServerDlg::init_tdoa_all_readers_coverage(int reader_id)
{
	CMysqlConn* pConn = NULL;
	CDBConnGuard pDbGuard(pConn);

	//无可用数据库连接
	if(pConn == NULL){
		return -1;
	}

	char sql[LENGTH_SQL] = {0};
	if(reader_id == 0){
		sprintf_s(sql, "select p.start_reader_id,p.end_reader_id,p.idx,p.x,p.y,p.z,p.is_bezier from dat_reader_path_tdoa p ,dat_reader r where p.start_reader_id = r.reader_id;");
	}else{
		sprintf_s(sql, "select start_reader_id,end_reader_id,idx,x,y,z,is_bezier from dat_reader_path_tdoa where reader_id = %d; ", reader_id);
	}

	MYSQL_RES* pRes = NULL;
	MYSQL_ROW pRow;
	int err = 0;
	int nRow = 0;

	//查询数据库
	pRes = pConn->Execute(sql,err);

	double mapScale = 0.0;
	while(pRow = mysql_fetch_row(pRes)){
		int start_reader_id = atoi(pRow[0]);
		int end_reader_id   = atoi(pRow[1]);
		int ndx = atoi(pRow[2]);

		//后缀_r都为冗余信息
		ReaderPath* prp = NULL;
		ReaderPath* prp_r = NULL;

		TDOAReaderPathMap::iterator it = mp_reader_path_list_tdoa.find(start_reader_id);	

		if(it == mp_reader_path_list_tdoa.end()){
			ReaderPathMap* prpm = new ReaderPathMap();
			ReaderPath* prp1 = new ReaderPath();
			prpm->insert(make_pair(end_reader_id,prp1));
			mp_reader_path_list_tdoa.insert(make_pair(start_reader_id,*prpm));	

			//冗余数据
			ReaderPathMap* prpm_r = new ReaderPathMap();
			ReaderPath* prp1_r = new ReaderPath();
			prpm_r->insert(make_pair(start_reader_id,prp1_r));
			mp_reader_path_list_tdoa.insert(make_pair(end_reader_id,*prpm_r));		
		}else{
			ReaderPathMap::iterator it2;
			it2 = it->second.find(end_reader_id);
			if(it2 == it->second.end()){
				ReaderPath* prp1 = new ReaderPath();
				it->second.insert(make_pair(end_reader_id,prp1));

				//冗余数据
				ReaderPathMap* prpm_r = new ReaderPathMap();
				ReaderPath* prp1_r = new ReaderPath();
				prpm_r->insert(make_pair(start_reader_id,prp1_r));
				mp_reader_path_list_tdoa.insert(make_pair(end_reader_id,*prpm_r));
			}
		}

		ReaderPathMap::iterator it_rpm = mp_reader_path_list_tdoa.find(start_reader_id)->second.find(end_reader_id);
		if(it_rpm!=mp_reader_path_list_tdoa.find(start_reader_id)->second.end()){
			prp = it_rpm->second;
		}else{
			prp = new ReaderPath();
		}

		//冗余信息
		ReaderPathMap::iterator it_rpm_r = mp_reader_path_list_tdoa.find(end_reader_id)->second.find(start_reader_id);
		if(it_rpm_r!=mp_reader_path_list_tdoa.find(end_reader_id)->second.end()){
			prp_r = it_rpm_r->second;
		}else{
			prp_r = new ReaderPath();
		}

		//获得地图比例
		int map_id = mp_reader_list.find(start_reader_id)->second->map_id;
		MapInfoMap::iterator mit = mp_map_list.find(map_id);
		if(mit == mp_map_list.end()){
			//没有相关地图信息，要输出错误日志
			AfxMessageBox(_T("分站所在地图不存在！"));
			break;
		}
		mapScale = mp_map_list.find(map_id)->second->map_scale;

		//获得分站坐标，其中索引0表示起始分站坐标，索引1表示结束分站坐标
		prp->x[0] = mp_reader_list.find(start_reader_id)->second->reader_x*mapScale;
		prp->y[0] = mp_reader_list.find(start_reader_id)->second->reader_y*mapScale;
		prp->x[1] = mp_reader_list.find(end_reader_id)->second->reader_x*mapScale;
		prp->y[1] = mp_reader_list.find(end_reader_id)->second->reader_y*mapScale;
		prp->px[ndx-1] = atof(pRow[3])*mapScale;
		prp->py[ndx-1] = atof(pRow[4])*mapScale;
		prp->nRealCalcPoints++;

		//冗余信息
		prp_r->x[0] = mp_reader_list.find(end_reader_id)->second->reader_x*mapScale;
		prp_r->y[0] = mp_reader_list.find(end_reader_id)->second->reader_y*mapScale;
		prp_r->x[1] = mp_reader_list.find(start_reader_id)->second->reader_x*mapScale;
		prp_r->y[1] = mp_reader_list.find(start_reader_id)->second->reader_y*mapScale;
		prp_r->px[ndx-1] = atof(pRow[3])*mapScale;
		prp_r->py[ndx-1] = atof(pRow[4])*mapScale;
		prp_r->nRealCalcPoints++;
	}
	mysql_free_result(pRes);

	//输出操作结果信息
	CString strlog;
	strlog.Format(_T("%s%d%s"), _T(LOG_INIT_VEHICLE), nRow, _T(LOG_RECORD_COUNT));
	show_log(strlog);

	return 0;
}

//int CYAServerDlg::init_adhoc( string adhoc_id /*= ""*/ )
//{
//	CMysqlConn* pConn = NULL;
//	CDBConnGuard pDbGuard(pConn);
//	MYSQL_RES* pRes;
//	MYSQL_ROW pRow;
//	int err = 0;
//	char buf[LENGTH_SQL] = {0};
//	if(adhoc_id.length() == 0){
//		sprintf_s(buf, "SELECT vehicle_id, v.card_id, c.card_type_id, v.name, v.number, \
//					   v.dept_id, v.group_id, v.vehicle_type_id, \
//					   d.name as dname, g.name as gname, vt.name as vtname, v.dept_id \
//					   FROM dat_vehicle v \
//					   LEFT JOIN dat_card c ON v.card_id = c.card_id \
//					   LEFT JOIN dat_dept d ON v.dept_id = d.dept_id \
//					   LEFT JOIN dat_group g ON v.group_id = g.group_id \
//					   LEFT JOIN dat_vehicle_type vt ON v.vehicle_type_id = vt.vehicle_type_id \
//					   WHERE c.card_type_id = 2 and v.state = 0;");
//	}else{
//		sprintf_s(buf, "SELECT vehicle_id, v.card_id, c.card_type_id, v.name, v.number, \
//					   v.dept_id, v.group_id, v.vehicle_type_id, \
//					   d.name as dname, g.name as gname, vt.name as vtname, v.dept_id \
//					   FROM dat_vehicle v \
//					   LEFT JOIN dat_card c ON v.card_id = c.card_id \
//					   LEFT JOIN dat_dept d ON v.dept_id = d.dept_id \
//					   LEFT JOIN dat_group g ON v.group_id = g.group_id \
//					   LEFT JOIN dat_vehicle_type vt ON v.vehicle_type_id = vt.vehicle_type_id \
//					   WHERE c.card_type_id = 2 and v.state = 0 AND vehicle_id='%s';", vehicle_id);
//	}
//	pRes = pConn->Execute(buf, err);
//	Card* pCard = NULL;
//	int nRow = 0;
//	while(pRow = mysql_fetch_row(pRes)){
//		CardMap::iterator it = mp_card_list_all.find(pRow[1]);
//		if(it != mp_card_list_all.end()){
//			pCard = it->second;
//		}else{
//			pCard = new Card(pRow[1], atoi(pRow[2]), theApp.z_offset, map_offset_x, map_offset_y);
//			mp_card_list_all.insert(make_pair(pCard->card_id, pCard));
//			nRow++;
//		}
//		pCard->id = (pRow[0] == NULL) ? "" : pRow[0];
//		pCard->name = (pRow[3] == NULL) ? "" : pRow[3];
//		pCard->number = (pRow[4] == NULL) ? "" : pRow[4];
//		pCard->department = (pRow[8] == NULL) ? "" : pRow[8];
//		pCard->group = (pRow[9] == NULL) ? "" : pRow[9];
//		pCard->worktype = (pRow[10] == NULL) ? "" : pRow[10];
//		pCard->dept_id = atoi(pRow[11]);
//	}
//	mysql_free_result(pRes);
//	CString strlog;
//	strlog.Format(_T("%s%d%s"), _T(LOG_INIT_VEHICLE), nRow, _T(LOG_RECORD_COUNT));
//	show_log(strlog);
//	return 0;
//}

void CYAServerDlg::ws_init()
{
	is_websocket_ok = false;
	is_websocket_login = false;
	using std::placeholders::_1;
	using std::placeholders::_2;
	using std::placeholders::_3;
	using std::placeholders::_4;
	socket::ptr sock = _io->socket();
	//default socket opened, also we have "set_open_listener" for monitoring physical connection opened.
	//sock->on(JSON_CMD_VALUE_USER, sio::socket::event_listener_aux(std::bind(&CYAServerDlg::OnLoginMessage,this,_1,_2,_3,_4)));
	sock->on(JSON_CMD_VALUE_USER, sio::socket::event_listener_aux(std::bind(&CYAServerDlg::OnLogin, this, _1,_2,_3,_4)));
	sock->on(JSON_CMD_VALUE_CALL, sio::socket::event_listener_aux(std::bind(&CYAServerDlg::OnCallMessage,this,_1,_2,_3,_4)));
	sock->on(JSON_CMD_VALUE_PUSH, sio::socket::event_listener(std::bind(&CYAServerDlg::OnPushMessage, this)));
	//sock->on(JSON_CMD_VALUE_USER, sio::socket::event_listener(std::bind(&CYAServerDlg::OnLoginCallBack, this, std::placeholders::_1)));
	_io->set_socket_open_listener(std::bind(&CYAServerDlg::OnConnected, this));
	//physical connection closed or drop.
	_io->set_close_listener(std::bind(&CYAServerDlg::OnClosed,this, std::placeholders::_1));
	//physical connection fail to establish.
	_io->set_fail_listener(std::bind(&CYAServerDlg::OnFailed,this));
}

void CYAServerDlg::ws_close()
{
	//_io->socket()->off_all();
	//_io->socket()->off_error();
}

void CYAServerDlg::ws_login()
{
	USES_CONVERSION;
	CC2UTF8 conv = (char*)get_json_login().c_str();
	string szlogin = conv.c_str();
	_io->socket()->emit(JSON_CMD_VALUE_USER, szlogin, [&](sio::message::list const& msglist){
		message::ptr msg_ptr = msglist[0];
		int n =(int)msg_ptr->get_map()["code"]->get_int();
		is_websocket_login = (0 == n) ? true : false;
		if(is_websocket_login){
			CString strlog;
			strlog.Format(_T("%s: %s"), _T(LOG_LOGIN_WEB_SERVER), CFunctions::c2wc(m_ws_url.c_str()));
			show_log(strlog);
		}
	});
}

void CYAServerDlg::ws_logout()
{
	send_json_data(JSON_CMD_VALUE_USER, get_json_logout().c_str());
	CString strlog;
	strlog.Format(_T("%s: %s"), _T(LOG_LOGOUT_WEB_SERVER), CFunctions::c2wc(m_ws_url.c_str()));
	show_log(strlog);
}

void CYAServerDlg::start_tcp_server()
{
	set_app_state(ST_STARTING);

	if(_server.Start(LOCAL_ADDRESS, PORT_SERVER_MASTER))
	{
		::LogServerStart(LOCAL_ADDRESS, PORT_SERVER_MASTER);
		set_app_state(ST_STARTED);
	}
	else
	{
		::LogServerStartFail(_server.GetLastError(), _server.GetLastErrorDesc());
		set_app_state(ST_STOPPED);
	}
}

void CYAServerDlg::stop_tcp_server()
{
	set_app_state(ST_STOPPING);
	if(_server.Stop()){
		::LogServerStop();
		set_app_state(ST_STOPPED);
	}
	else{
		ASSERT(FALSE);
	}
}

void CYAServerDlg::clear_listener()
{
	//SocketMap::iterator it_sock = mp_socket_list.begin();
	//for(; it_sock != mp_socket_list.end();){
	//	it_sock->second->Close();
	//	mp_socket_list.erase(it_sock++);
	//}
}

void CYAServerDlg::clear_all_list()
{
	// 清空创建的对象
	//mp_card_list_all.clear();
	//mp_reader_list.clear();
	//mp_area_list.clear();
	//mp_map_list.clear();
}

void CYAServerDlg::parse_data(const BYTE *pData, int nLen,  DWORD dwConnID)
{
	CString strBuf;
	formatByteArray(strBuf, (BYTE*)pData, nLen);
	writeErrorLog(_T("RAW_SS"), strBuf, false);
	WORD tmplen = 0;

	SocketBufferMap::iterator it = mp_socket_buffer_list.find(dwConnID);
	if(it != mp_socket_buffer_list.end()){ // 有此socket数据
		if(0 == it->second->wReadLen){ // 新的数据包
			memset(it->second->pData, 0, LENGTH_MSG_4K);
			tmplen = MAKEWORD(pData[1], pData[0]) + sizeof(WORD); // 加上描述长度的两字节
			it->second->wLen = tmplen;
			if(tmplen > nLen){
				tmplen = nLen;
			}
			memcpy(it->second->pData, pData, tmplen);
		}else{ // 接着上一次收取
			tmplen = min(nLen, it->second->wLen - it->second->wReadLen);
			memcpy(&it->second->pData[it->second->wReadLen], pData, tmplen);
		}
		it->second->wReadLen += tmplen;
		if(it->second->wReadLen >= it->second->wLen){ // 接收完毕
			parse_data_receive(it->second->pData, it->second->wLen, dwConnID);
			it->second->wReadLen = 0; // 重置
		}
	}else{ // 无此socket数据
		_SOCKET_BUFFER* _sockbuf = new _SOCKET_BUFFER;
		_sockbuf->wReadLen = 0;
		_sockbuf->dwConnID = dwConnID;
		_sockbuf->wLen = MAKEWORD(pData[1], pData[0]) + sizeof(WORD); // 加上描述长度的两个字节
		memset(_sockbuf->pData, 0, LENGTH_MSG_4K);
		memcpy(_sockbuf->pData, pData, nLen);
		_sockbuf->wReadLen += nLen;
		mp_socket_buffer_list.insert(make_pair(dwConnID, _sockbuf));
		if(_sockbuf->wReadLen >= _sockbuf->wLen){
			parse_data_receive(_sockbuf->pData, nLen, dwConnID);
			_sockbuf->wReadLen = 0;
		}
	}
}

void CYAServerDlg::parse_data_receive(BYTE *pData, int nLen, DWORD dwConnID )
{
	CString strBuf;
	formatByteArray(strBuf, (BYTE*)pData, nLen);
	writeErrorLog(_T("RAW_S"), strBuf, false);

	int total_pos = 0;
	WORD pkg_len = 0;

	while(total_pos < nLen){ // 处理粘包
		if(total_pos + sizeof(WORD) >= nLen){
			int aa = 20;
			//break;
		}
		pkg_len = MAKEWORD(pData[total_pos+1], pData[total_pos]); // 单个数据包长度

		if(total_pos + pkg_len> nLen) 
		{
			int aa = 20;
		}

		BYTE* DataBuffer = new BYTE[pkg_len];
		memset(DataBuffer, 0, pkg_len);
		memcpy(DataBuffer, &pData[total_pos + sizeof(WORD)], pkg_len); // 一个数据包		
		parse_package_data(DataBuffer, pkg_len, dwConnID);	// 解析数据包	
		delete[] DataBuffer;

		total_pos += pkg_len + sizeof(WORD); // 数据包长度 + 长度自身两个字节
	}
}

void CYAServerDlg::parse_package_data( BYTE* DataBuffer, int nLen, DWORD dwConnID )
{
	WORD wCrc = CFunctions::getCRC(&DataBuffer[0], nLen - sizeof(WORD)); // CRC校验码
	WORD w ;
	CString strBuf;
	CFunctions::getWord(DataBuffer, &w, nLen - sizeof(WORD));
	if( w  != wCrc ){ // 校验不对
		if(theApp.log_raw_data){
			strBuf = _T("CRC校验不通过");
			writeErrorLog(_T("RAW_S"), strBuf);
		}
		return;
	}
	int nCurPos = 0; 
	WORD wChr = 0;
	CFunctions::getWord(DataBuffer, &wChr, nCurPos);
	nCurPos += sizeof(WORD);
	int reader_id = 0;
	int nTick = 0;
	CString strtime;
	switch (wChr){
	case CHAR_LOCATEDATA: // 定位数据
		{
			parse_data_locate_reader(DataBuffer, nCurPos, nLen, dwConnID, reader_id);			
			while(nCurPos < nLen - (int)sizeof(WORD)){ // 减去crc
				parse_data_locate_card(DataBuffer, nCurPos, reader_id, wChr);
			}
			break;
		}
	case CHAR_LOCATEDATA_TDOA:
		{
			parse_data_locate_reader(DataBuffer, nCurPos, nLen, dwConnID, reader_id);			
			while(nCurPos < nLen - (int)sizeof(WORD)){ // 减去crc
				parse_data_locate_card(DataBuffer, nCurPos, reader_id, wChr);
			}
			break;
		}
	case CHAR_LOCATEDATAHIS:
		{
			parse_data_locate_reader_his(DataBuffer, nLen, nCurPos, reader_id, nTick, strtime, wChr);
			while(nCurPos < nLen - (int)sizeof(WORD)){ // 减去crc
				parse_data_locate_card_his(DataBuffer, nCurPos, reader_id, nTick, strtime, wChr);
			}
			break;
		}
	case CHAR_LOCATEDATAHIS_TDOA:
		{
			parse_data_locate_reader_his(DataBuffer, nLen, nCurPos, reader_id, nTick, strtime, wChr);
			while(nCurPos < nLen - (int)sizeof(WORD)){ // 减去crc
				parse_data_locate_card_his(DataBuffer, nCurPos, reader_id, nTick, strtime, wChr);
			}
		}
	case CHAR_TIMESYNC:
		{
			parse_data_reader_synctime(DataBuffer ,nLen ,nCurPos);
			break;
		}
	case CHAR_ADHOC:
		{
			parse_data_locate_reader(DataBuffer, nCurPos, nLen, dwConnID, reader_id);
			while(nCurPos < nLen - (int)sizeof(WORD)){ // 减去crc
				parse_data_adhoc(DataBuffer, nCurPos, reader_id);
			}
		}
	default:
		//WriteInfoFile("未能解析的命令！");
		break;
	}
}

void CYAServerDlg::parse_data_locate_reader(BYTE * DataBuffer, int& nCurPos, int nLen, DWORD dwConnID, int& reader_id )
{
	// 分站号
	DWORD dwReaderID;
	CFunctions::getDWord(DataBuffer, &dwReaderID, nCurPos);
	nCurPos += sizeof(DWORD);

	reader_id = dwReaderID;
	//_SOCK* sock = get_socket_by_count(dwConnID);
	//if(NULL == sock){ // 列表中不存在
	//	if(_server.Disconnect(dwConnID))
	//		::LogDisconnect(dwConnID);
	//	else
	//		::LogDisconnectFail(dwConnID);
	//	return;
	//}
	ReaderMap::iterator itReader = mp_reader_list.find(dwReaderID);
	Reader* pReader;
	if(itReader != mp_reader_list.end()){
		pReader = itReader->second;
		add_socket_to_list(dwConnID, reader_id);
	}else{
		pReader = new Reader();
		pReader->reader_id = dwReaderID;
		//mp_reader_list.insert(make_pair(dwReaderID, pReader)); // 只处理在数据库中维护的
	}
	// 接收数据时间
	pReader->rec_time = time(NULL); // COleDateTime::GetTickCount();
	m_time_last_rec = pReader->rec_time; // 更新最后信号时间
	// 分站时间戳
	WORD wTickCount = 0;
	CFunctions::getWord(DataBuffer, &wTickCount, nCurPos);
	nCurPos += sizeof(WORD);
	pReader->tick_count = wTickCount;
	// 分站时间
	// 7字节 从第一个字节开始，分别表示秒、分、时、天、周、月、年
	BYTE btSec = 0;
	memcpy(&btSec, &DataBuffer[nCurPos], sizeof(BYTE));
	nCurPos += sizeof(BYTE);
	BYTE btMin = 0;
	memcpy(&btMin, &DataBuffer[nCurPos], sizeof(BYTE));
	nCurPos += sizeof(BYTE);
	BYTE btHour = 0;
	memcpy(&btHour, &DataBuffer[nCurPos], sizeof(BYTE));
	nCurPos += sizeof(BYTE);
	BYTE btDay = 0;
	memcpy(&btDay, &DataBuffer[nCurPos], sizeof(BYTE));
	nCurPos += sizeof(BYTE);
	BYTE btWeek = 0;
	memcpy(&btWeek, &DataBuffer[nCurPos], sizeof(BYTE));
	nCurPos += sizeof(BYTE);
	BYTE btMonth = 0;
	memcpy(&btMonth, &DataBuffer[nCurPos], sizeof(BYTE));
	nCurPos += sizeof(BYTE);
	BYTE btYear = 0;
	memcpy(&btYear, &DataBuffer[nCurPos], sizeof(BYTE));
	nCurPos += sizeof(BYTE);
	struct tm reader_time;
	reader_time.tm_sec = btSec;
	reader_time.tm_min = btMin;
	reader_time.tm_hour = btHour;
	reader_time.tm_mday = btDay;
	reader_time.tm_wday = btWeek;
	reader_time.tm_mon = btMonth - 1;
	reader_time.tm_year = btYear + 100;  // + 2000 - 1900
	pReader->reader_time = mktime(&reader_time);

	// 温度
	BYTE btTemperature = 0;	
	memcpy(&btTemperature, &DataBuffer[nCurPos], sizeof(BYTE));
	nCurPos += sizeof(BYTE);
	pReader->temperature = btTemperature;
	// 状态
	WORD wState = 0;
	CFunctions::getWord(DataBuffer, &wState, sizeof(WORD));
	nCurPos += sizeof(WORD);
	// pReader->state = wState;
	if(theApp.log_parse_data){
		CString strLog;
		strLog.Format(_T("id:%d, n:%d, %.2d-%.2d-%.2d %.2d:%.2d:%.2d, tep:%d, sta:%d"), 
			dwReaderID, wTickCount, btYear, btMonth, btDay, btHour, btMin, btSec, btTemperature, wState);
		writeErrorLog(_T("PARSE_S"), strLog);
	}
}

void CYAServerDlg::parse_data_locate_card(BYTE* DataBuffer, int& nCurPos, int reader_id, unsigned short wChr)
{
	ReaderMap::iterator it = mp_reader_list.find(reader_id);
	if(it != mp_reader_list.end()){
		// 卡类型
		BYTE btCardType = 0;
		memcpy(&btCardType, &DataBuffer[nCurPos], sizeof(BYTE));
		nCurPos += sizeof(BYTE);
		// 卡号
		DWORD dwCardId = 0;
		CFunctions::getDWord(DataBuffer, &dwCardId, nCurPos);
		nCurPos += sizeof(DWORD);
		// 获取标识卡编号, 3位卡类型 + 10位卡号
		string str_card_id = CFunctions::getstrwithzero(btCardType, 3) + CFunctions::getstrwithzero(dwCardId, 10);
		Card* card = NULL;
		CardMap::iterator it_card = mp_card_list_all.find(str_card_id);
		if(it_card != mp_card_list_all.end()){
			card = it_card->second;
		}else{
			card = new Card(str_card_id, btCardType, theApp.z_offset);
			mp_card_list_all.insert(make_pair(str_card_id, card));
		}
		// 设置当前分站， 进入分站时间、进入区域时间，当前区域，当前地图
		card->set_reader(it->second);
#ifdef ALGORITHM_TYPE_TOF
		card->set_reader_path(&mp_reader_path_list);
#elif defined ALGORITHM_TYPE_TDOA
		card->set_reader_path(&mp_reader_path_list_tdoa);
#endif
		card->reader_tickcount = it->second->tick_count;
		card->is_hist = false;

		switch(btCardType)
		{
		case CT_VEHICLE: 
			parse_data_locate_card_vehicle(DataBuffer, nCurPos, card, wChr);
			deal_card(card);
			break;
		case CT_PERSON:
			{
				break;
			}
		default:
			{
				//strBuf = "";
				//strBuf.Format(_T("无法识别的卡类型:%d\r\n"), btCardType);
				//return ;
				break;
			}
		}
	}
}

void CYAServerDlg::parse_data_locate_card_vehicle(BYTE* DataBuffer, int& nCurPos, Card* card, unsigned short wChr )
{
	if(LT_READER == theApp.locate_type){
		card->isdealed = false;
		card->isreceive = true;
		card->issent = false;
	}
	// 报文时间
	WORD wCardTickCount;
	CFunctions::getWord(DataBuffer, &wCardTickCount, nCurPos);
	nCurPos += sizeof(WORD);

	if(wCardTickCount == 14){
		int sss = 13;
		sss = wCardTickCount;
	}

	BYTE btTypeAndPower;
	memcpy(&btTypeAndPower, &DataBuffer[nCurPos], sizeof(BYTE));
	nCurPos += sizeof(BYTE);
	//报文类型
	BYTE btType;
	btType = (btTypeAndPower >>4) & 0x0F;

	//电池电量
	BYTE btPower;
	btPower = btTypeAndPower & 0x0F;

	//保留
	nCurPos += sizeof(BYTE);
	//加速度
	BYTE btAcceleration;
	memcpy(&btAcceleration, &DataBuffer[nCurPos], sizeof(BYTE));
	nCurPos += sizeof(BYTE);

	//定位时间戳Tsp // 字序
	LONG64 lTime1 = 0;
	BYTE btTemp = 0;
	int nRangingPos = nCurPos;
	memcpy(&btTemp, &DataBuffer[nCurPos], sizeof(BYTE));
	nCurPos += sizeof(BYTE);
	DWORD dwTemp = 0;
	CFunctions::getDWord(DataBuffer, &dwTemp, nCurPos);
	nCurPos += sizeof(DWORD);
	lTime1 = btTemp;
	lTime1 = lTime1 << 32;
	lTime1 |=  ((long long)dwTemp & 0xffffffff);
	// 距离
	double dldist =  CFunctions::getDistance(lTime1);
	//dldist *= card->map_scale;
	// 天线
	BYTE btAntenna;
	memcpy(&btAntenna, &DataBuffer[nCurPos], sizeof(BYTE));
	nCurPos += sizeof(BYTE);

	WORD wSyncNum = 0;
	WORD wStrength = 0;
	if(CHAR_LOCATEDATA_TDOA == wChr){
		// 分站时间同步序列号 
		CFunctions::getWord(DataBuffer, &wSyncNum, nCurPos);
		nCurPos += sizeof(WORD);
		// 信号强度		
		CFunctions::getWord(DataBuffer, &wStrength, nCurPos);
		nCurPos += sizeof(WORD);
	}

	if(LT_COORDINATE == theApp.locate_type){
		card->time_stamp = wCardTickCount;
		card->ranging_type = btType;
		card->power_state = btPower;
		card->accelerate_state = btAcceleration;
		card->flying_time = lTime1;
		card->sync_num = wSyncNum;
		card->antenna_id = ((btAntenna & 0xFF) == 1) ? 0 : 1;
		card->distance = dldist;

		if(theApp.log_parse_data){
			CString strLog;
			strLog.Format(_T("id:%s, n:%d, type:%d, power:%d, acc:%d, flytime:%I64u, d:%f, ant:%d, syncnum:%d, strength:%d"), 
				CFunctions::c2wc(card->card_id.c_str()), wCardTickCount, btType, btPower, btAcceleration, lTime1, dldist, btAntenna, wSyncNum, wStrength);
			writeErrorLog(_T("PARSE_S"), strLog, true);
		}
	}else if(LT_READER == theApp.locate_type){
		if(card->time_stamp < 0xFF && card->time_stamp < wCardTickCount){
			card->time_stamp = wCardTickCount;
			card->ranging_type = btType;
			card->power_state = btPower;
			card->accelerate_state = btAcceleration;
			card->flying_time = lTime1;
			card->sync_num = wSyncNum;
			card->antenna_id = ((btAntenna & 0xFF) == 1) ? 0 : 1;
			card->distance = dldist;
		}else if(0xFF == card->time_stamp && wCardTickCount == 0){
			card->time_stamp = wCardTickCount;
			card->ranging_type = btType;
			card->power_state = btPower;
			card->accelerate_state = btAcceleration;
			card->flying_time = lTime1;
			card->sync_num = wSyncNum;
			card->antenna_id = ((btAntenna & 0xFF) == 1) ? 0 : 1;
			card->distance = dldist;
		}
	}
}

void CYAServerDlg::parse_data_adhoc( BYTE* DataBuffer, int& nCurPos, int reader_id )
{
	ReaderMap::iterator it = mp_reader_list.find(reader_id);
	if(it != mp_reader_list.end()){
		//	BYTE nlen = 0, nDeal = nCurPos;
		//	memcpy(&nlen, &DataBuffer[nCurPos], sizeof(BYTE));
		//	nCurPos += sizeof(BYTE);
		//	while (nlen > nCurPos - nDeal){
		BYTE btCmd = 0;
		memcpy(&btCmd, &DataBuffer[nCurPos], sizeof(BYTE));
		nCurPos += sizeof(BYTE);
		BYTE btDiret = (btCmd >> 6);
		if(btDiret == 0x02){ // 只处理上传数据，0x00、0x03 保留，0x01下发数据，0x02上传数据
			btCmd &= 0x3F;  // 高两位为命令传递方向，上位机无用
			BYTE btId = 0;
			memcpy(&btId, &DataBuffer[nCurPos], sizeof(BYTE));
			nCurPos += sizeof(BYTE);
			BYTE btTickcount = 0;
			memcpy(&btTickcount, &DataBuffer[nCurPos], sizeof(BYTE));
			nCurPos += sizeof(BYTE);
			BYTE btIdx = 0;
			memcpy(&btIdx, &DataBuffer[nCurPos], sizeof(BYTE));
			nCurPos += sizeof(BYTE);

			if(btId != 0){
				string str_card_id = CFunctions::getstrwithzero(CT_ADHOC, 3) + CFunctions::getstrwithzero(btId, 10);
				Card* card = NULL;
				CardMap::iterator it_card = mp_card_list_all.find(str_card_id);
				if(it_card != mp_card_list_all.end()){
					card = it_card->second;
				}else{
					card = new Card(str_card_id, CT_ADHOC, theApp.z_offset);
					mp_card_list_all.insert(make_pair(str_card_id, card));
				}
				//设置当前分站， 进入分站时间、进入区域时间，当前区域，当前地图
				card->set_reader(it->second);
				if(it->second->adhoc[btIdx]){
					card->x = it->second->adhoc[btIdx]->x;
					card->y = it->second->adhoc[btIdx]->y;
					card->z = it->second->adhoc[btIdx]->z;
				}

				if(btCmd & 0x01){ // 呼救

				}else if(btCmd & 0x02){ // 呼叫应答，即呼叫成功
					if(STATUS_NORMAL == card->status_call){

					}
				}else {
					card->status_call = STATUS_NORMAL;
					card->status_help = STATUS_NORMAL;
				}
				card->issent = false;
				//if(card->status_help != btCmd){
				//	card->status_help = btCmd;
				//}
				deal_card(card);
			}
		}else{
			nCurPos += 3 * sizeof(BYTE);
		}
		//	}.
	}
}

void CYAServerDlg::add_socket_to_list(DWORD dwConnID, DWORD reader_id )
{
	TCHAR szAddress[40];
	int iAddressLen = sizeof(szAddress) / sizeof(TCHAR);
	USHORT usPort;
	_server.GetRemoteAddress(dwConnID, szAddress, iAddressLen, usPort);

	SocketMap::iterator itSock = mp_socket_list.find(szAddress);
	if(itSock != mp_socket_list.end()){
		itSock->second->dwConnID = dwConnID;
		itSock->second->state = 0;
		itSock->second->reader_id = reader_id;
	}else{
		_SOCK *sock = new _SOCK();
		sock->sip = szAddress;
		sock->dwConnID = dwConnID;
		sock->state = 0;
		sock->reader_id = reader_id;
		mp_socket_list.insert(make_pair(szAddress, sock));

		::PostMessage(this->GetSafeHwnd(), MSG_REFRESH_IP_LIST, 0, 0);
	}
}

void CYAServerDlg::remove_socket(DWORD dwConnID )
{
	EnterCriticalSection(&m_csRemoveSocket);
	bool bNeedRefresh = false;
	SocketMap::iterator _sock = mp_socket_list.begin();
	while(_sock != mp_socket_list.end()){
		if(_sock->second->dwConnID == dwConnID){
			mp_socket_list.erase(_sock++);
			bNeedRefresh = true;
		}else{
			++_sock;
		}
	}
	if(bNeedRefresh){
		::PostMessage(this->GetSafeHwnd(), MSG_REFRESH_IP_LIST, 0, 0);
	}
	LeaveCriticalSection(&m_csRemoveSocket);
}

// 获取设备状态信息, 分站、红绿灯、道岔、扩音器
std::string CYAServerDlg::get_json_device_state()
{
	char _time[STR_LEN_TIME];
	struct tm local_time;
	Json::Value root;	
	Json::Value state_maps;
	MapInfoMap::iterator it_map = mp_map_list.begin();
	int nn = 0;
	for(; it_map != mp_map_list.end(); ++it_map){
		Json::Value state_map;
		Json::Value state_devs;
		int n = 0;
		ReaderMap::iterator it = mp_reader_list.begin();
		for(; it != mp_reader_list.end(); ++it){
			if(it->second->map_id != it_map->second->map_id) continue;
			//if(it->second->state != it->second->state_old){
			Json::Value state_dev;
			state_dev[JSON_KEY_DEV_STATE_DEVICE_ID] = it->second->reader_id;
			state_dev[JSON_KEY_DEV_STATE_STATE_DESC] = it->second->get_state_text();
			state_dev[JSON_KEY_DEV_STATE_STATE] = it->second->state;
			state_dev[JSON_KEY_DEV_STATE_DEVICE_TYPE_ID] = it->second->device_type_id;
			localtime_s(&local_time, &it->second->rec_time);
			strftime(_time, STR_LEN_TIME, "%Y-%m-%d %H:%M:%S", &local_time);
			state_dev[JSON_KEY_DEV_STATE_TIME] = _time;
			n++;
			state_devs.append(state_dev);
			it->second->state_old = it->second->state;
			//}
		}
		if(n >0){
			state_map[JSON_KEY_DEV_STATE_MAP_ID] = it_map->second->map_id;
			state_map[JSON_KEY_DEV_STATE_DEVICES] = state_devs;
			nn++;
			state_maps.append(state_map);
		}
	}
	if(nn>0){
		root[JSON_ROOT_KEY_CMD] = JSON_CMD_VALUE_DEV_STATE;
		root[JSON_ROOT_KEY_DATA] = state_maps;
		return root.toFastString();
	}
	return "";
}

std::string CYAServerDlg::get_json_alarm()
{
	Json::Value root;
	Json::Value data;
	Json::Value _global;
	Json::Value _areas;
	Json::Value _readers;
	Json::Value _staff;
	Json::Value _vehicle;

	unsigned int alarm_count = 0;
	char _time[STR_LEN_TIME];
	struct tm local_time;
	// global
	// 人员超员
	alarm_count = mp_card_list_down_person.size();
	if(alarm_count > sls_setting.over_count_person){ // if(time_over_count_person >0)
		Json::Value alarm;
		Json::Value detail;
		alarm[JSON_KEY_ALARM_ITEM] = JSON_KEY_ALARM_OVER_COUNT_PERSON;
		detail[JSON_KEY_ALARM_MAX] = sls_setting.over_count_person;
		detail[JSON_KEY_ALARM_CURRENT] = alarm_count;
		alarm[JSON_KEY_ALARM_DETAIL] = detail;
		_global.append(alarm);
	}
	// 车辆超员
	alarm_count = mp_card_list_down_vehicle.size();
	if(alarm_count > sls_setting.over_count_vehicle){
		Json::Value alarm;
		Json::Value detail;
		alarm[JSON_KEY_ALARM_ITEM] = JSON_KEY_ALARM_OVER_COUNT_VEHICLE;
		detail[JSON_KEY_ALARM_MAX] = sls_setting.over_count_vehicle;
		detail[JSON_KEY_ALARM_CURRENT] = alarm_count;
		alarm[JSON_KEY_ALARM_DETAIL] = detail;
		_global.append(alarm);
	}
	// 人员超时
	alarm_count = mp_card_list_over_time_person.size();
	if(alarm_count > 0){
		Json::Value alarm;
		Json::Value detail;
		alarm[JSON_KEY_ALARM_ITEM] = JSON_KEY_ALARM_OVER_TIME_PERSON;
		detail[JSON_KEY_ALARM_MAX] = sls_setting.over_time_person;
		detail[JSON_KEY_ALARM_CURRENT] = alarm_count;
		alarm[JSON_KEY_ALARM_DETAIL] = detail;
		_global.append(alarm);
	}
	// 车辆超时
	alarm_count = mp_card_list_over_time_vehicle.size();
	if(alarm_count > 0){
		Json::Value alarm;
		Json::Value detail;
		alarm[JSON_KEY_ALARM_ITEM] = JSON_KEY_ALARM_OVER_TIME_VEHICLE;
		detail[JSON_KEY_ALARM_MAX] = sls_setting.over_time_vehicle;
		detail[JSON_KEY_ALARM_CURRENT] = alarm_count;
		alarm[JSON_KEY_ALARM_DETAIL] = detail;
		_global.append(alarm);
	}
	// 车辆超速
	alarm_count = mp_card_list_over_speed_vehicle.size();
	if(alarm_count > 0){
		Json::Value alarm;
		Json::Value detail;
		alarm[JSON_KEY_ALARM_ITEM] = JSON_KEY_ALARM_OVER_TIME_VEHICLE;
		detail[JSON_KEY_ALARM_MAX] = sls_setting.over_speed;
		detail[JSON_KEY_ALARM_CURRENT] = alarm_count;
		alarm[JSON_KEY_ALARM_DETAIL] = detail;
		_global.append(alarm);
	}

	// areas
	// 人员超员
	AreaMap::iterator it_area = mp_area_list.begin();
	bool is_alarm = false;
	for(; it_area != mp_area_list.end(); ++it_area){
		is_alarm = false;
		Json::Value area;
		Json::Value alarms;
		if(it_area->second->count_area_over_count_person > 0){
			is_alarm = true;
			Json::Value alarm;
			Json::Value detail;
			alarm[JSON_KEY_ALARM_ITEM] = JSON_KEY_ALARM_OVER_COUNT_PERSON;
			detail[JSON_KEY_ALARM_MAX] =  it_area->second->over_count_person;
			detail[JSON_KEY_ALARM_CURRENT] = it_area->second->count_person;
			alarm[JSON_KEY_ALARM_DETAIL] = detail;
			alarms.append(alarm);
		}
		if(it_area->second->count_area_over_count_vehicle > 0){
			is_alarm = true;
			Json::Value alarm;
			Json::Value detail;
			alarm[JSON_KEY_ALARM_ITEM] = JSON_KEY_ALARM_OVER_COUNT_VEHICLE;
			detail[JSON_KEY_ALARM_MAX] =  it_area->second->over_count_vehicle;
			detail[JSON_KEY_ALARM_CURRENT] = it_area->second->count_vehicle;
			alarm[JSON_KEY_ALARM_DETAIL] = detail;
			alarms.append(alarm);
		}
		if(it_area->second->count_area_over_time_person > 0){
			is_alarm = true;
			Json::Value alarm;
			Json::Value detail;
			alarm[JSON_KEY_ALARM_ITEM] = JSON_KEY_ALARM_OVER_TIME_PERSON;
			detail[JSON_KEY_ALARM_MAX] =  it_area->second->over_time_person;
			detail[JSON_KEY_ALARM_CURRENT] = it_area->second->count_area_over_time_person;
			alarm[JSON_KEY_ALARM_DETAIL] = detail;
			alarms.append(alarm);
		}
		if(it_area->second->count_area_over_time_vehicle > 0){
			is_alarm = true;
			Json::Value alarm;
			Json::Value detail;
			alarm[JSON_KEY_ALARM_ITEM] = JSON_KEY_ALARM_OVER_TIME_VEHICLE;
			detail[JSON_KEY_ALARM_MAX] =  it_area->second->over_time_vehicle;
			detail[JSON_KEY_ALARM_CURRENT] = it_area->second->count_area_over_time_vehicle;
			alarm[JSON_KEY_ALARM_DETAIL] = detail;
			alarms.append(alarm);
		}
		if(it_area->second->count_area_forbidden_person > 0 || it_area->second->count_area_forbidden_vehicle > 0){
			is_alarm = true;
			Json::Value alarm;
			Json::Value detail;
			alarm[JSON_KEY_ALARM_ITEM] = JSON_KEY_ALARM_AREA_FORBIDDEN;
			detail[JSON_KEY_ALARM_PERSON] =  it_area->second->count_area_forbidden_person;
			detail[JSON_KEY_ALARM_VEHICLE] = it_area->second->count_area_forbidden_vehicle;
			alarm[JSON_KEY_ALARM_DETAIL] = detail;
			alarms.append(alarm);
		}
		if(is_alarm){
			area[JSON_KEY_ALARM_AREA_ID] = it_area->second->area_id;
			area[JSON_KEY_ALARM_ALARMS] = alarms;
			_areas.append(area);
		}
	}	
	// 分站
	ReaderMap::iterator it_reader = mp_reader_list.begin();
	alarm_count = 0;
	for(; it_reader != mp_reader_list.end(); ++it_reader){
		if (it_reader->second->state == STATUS_DEVICE_ERROR){
			Json::Value alarm;
			alarm[JSON_KEY_ALARM_READER_ID] = it_reader->second->reader_id;
			alarm[JSON_KEY_ALARM_TYPE_ID] = ATID_READER;
			AlarmTypeMap::iterator it_alarm = mp_alarm_type_list.find(ATID_READER);
			if(it_alarm != mp_alarm_type_list.end()){
				alarm[JSON_KEY_ALARM_TYPE_NAME] = it_alarm->second;
			}
			localtime_s(&local_time, &it_reader->second->rec_time);
			strftime(_time, STR_LEN_TIME, "%Y-%m-%d %H:%M:%S", &local_time);
			//strftime(_time, STR_LEN_TIME, "%m-%d %H:%M", &local_time);
			alarm[JSON_KEY_ALARM_START_TIME] = _time;
			_readers.append(alarm);
		}
	}
	CardMap::iterator it_staff = mp_card_list_down_person.begin();
	for(; it_staff != mp_card_list_down_person.end(); ++it_staff){
		if(it_staff->second->status_area_over_time == STATUS_NORMAL &&
			it_staff->second->status_area_forbidden == STATUS_NORMAL &&
			it_staff->second->status_over_time == STATUS_NORMAL &&
			it_staff->second->status_power == STATUS_NORMAL) {
				continue;
		}
		Json::Value alarms;
		Json::Value staff;
		if(it_staff->second->status_area_forbidden == STATUS_ERROR){
			Json::Value alarm;
			AlarmTypeMap::iterator it_alarm = mp_alarm_type_list.find(ATID_AREA_FORBIDDEN_PERSON);
			if(it_alarm != mp_alarm_type_list.end()){
				alarm[JSON_KEY_ALARM_TYPE_NAME] = it_alarm->second;
			}
			localtime_s(&local_time, &it_staff->second->time_area_forbidden);
			strftime(_time, STR_LEN_TIME, "%Y-%m-%d %H:%M:%S", &local_time);
			alarm[JSON_KEY_ALARM_START_TIME] = _time;
			alarms.append(alarm);
		}
		if(it_staff->second->status_area_over_time == STATUS_ERROR){
			Json::Value alarm;
			AlarmTypeMap::iterator it_alarm = mp_alarm_type_list.find(ATID_AREA_OVER_TIME_PERSON);
			if(it_alarm != mp_alarm_type_list.end()){
				alarm[JSON_KEY_ALARM_TYPE_NAME] = it_alarm->second;
			}
			localtime_s(&local_time, &it_staff->second->time_area_over_time);
			strftime(_time, STR_LEN_TIME, "%Y-%m-%d %H:%M:%S", &local_time);
			alarm[JSON_KEY_ALARM_START_TIME] = _time;
			alarms.append(alarm);
		}
		if(it_staff->second->status_over_time == STATUS_ERROR){
			Json::Value alarm;
			AlarmTypeMap::iterator it_alarm = mp_alarm_type_list.find(ATID_OVER_TIME_PERSON);
			if(it_alarm != mp_alarm_type_list.end()){
				alarm[JSON_KEY_ALARM_TYPE_NAME] = it_alarm->second;
			}
			localtime_s(&local_time, &it_staff->second->time_over_time);
			strftime(_time, STR_LEN_TIME, "%m-%d %H:%M", &local_time);
			alarm[JSON_KEY_ALARM_START_TIME] = _time;
			alarms.append(alarm);
		}
		if(it_staff->second->status_power == STATUS_ERROR){
			Json::Value alarm;
			AlarmTypeMap::iterator it_alarm = mp_alarm_type_list.find(ATID_POWER);
			if(it_alarm != mp_alarm_type_list.end()){
				alarm[JSON_KEY_ALARM_TYPE_NAME] = it_alarm->second;
			}
			localtime_s(&local_time, &it_staff->second->time_low_power);
			strftime(_time, STR_LEN_TIME, "%Y-%m-%d %H:%M:%S", &local_time);
			alarm[JSON_KEY_ALARM_START_TIME] = _time;
			alarms.append(alarm);
		}

		if(alarms != NULL){
			staff[JSON_KEY_ALARM_STAFFER_ID] = it_staff->second->id;
			staff[JSON_KEY_ALARM_ALARMS] = alarms;
			_staff.append(staff);
		}
	}
	CardMap::iterator it_vehicle = mp_card_list_down_vehicle.begin();
	for(; it_vehicle != mp_card_list_down_vehicle.end(); ++it_vehicle){
		if(it_vehicle->second->status_area_forbidden == STATUS_NORMAL &&
			it_vehicle->second->status_area_over_time == STATUS_NORMAL &&
			it_vehicle->second->status_over_speed == STATUS_NORMAL &&
			it_vehicle->second->status_over_time == STATUS_NORMAL &&
			it_vehicle->second->status_power == STATUS_NORMAL ){
				continue;
		}
		Json::Value alarms;
		Json::Value vehichle;
		if(it_vehicle->second->status_area_forbidden == STATUS_ERROR){
			Json::Value alarm;
			AlarmTypeMap::iterator it_alarm = mp_alarm_type_list.find(ATID_AREA_FORBIDDEN_VEHICLE);
			if(it_alarm != mp_alarm_type_list.end()){
				alarm[JSON_KEY_ALARM_TYPE_NAME] = it_alarm->second;
			}
			localtime_s(&local_time, &it_vehicle->second->time_area_forbidden);
			strftime(_time, STR_LEN_TIME, "%Y-%m-%d %H:%M:%S", &local_time);
			alarm[JSON_KEY_ALARM_START_TIME] = _time;
			alarms.append(alarm);
		}
		if(it_vehicle->second->status_area_over_time == STATUS_ERROR){
			Json::Value alarm;
			AlarmTypeMap::iterator it_alarm = mp_alarm_type_list.find(ATID_AREA_OVER_TIME_VEHICLE);
			if(it_alarm != mp_alarm_type_list.end()){
				alarm[JSON_KEY_ALARM_TYPE_NAME] = it_alarm->second;
			}
			localtime_s(&local_time, &it_vehicle->second->time_area_over_time);
			strftime(_time, STR_LEN_TIME, "%Y-%m-%d %H:%M:%S", &local_time);
			alarm[JSON_KEY_ALARM_START_TIME] = _time;
			alarms.append(alarm);
		}
		if(it_vehicle->second->status_over_time == STATUS_ERROR){
			Json::Value alarm;
			AlarmTypeMap::iterator it_alarm = mp_alarm_type_list.find(ATID_OVER_TIME_VEHICLE);
			if(it_alarm != mp_alarm_type_list.end()){
				alarm[JSON_KEY_ALARM_TYPE_NAME] = it_alarm->second;
			}
			localtime_s(&local_time, &it_vehicle->second->time_over_time);
			strftime(_time, STR_LEN_TIME, "%Y-%m-%d %H:%M:%S", &local_time);
			alarm[JSON_KEY_ALARM_START_TIME] = _time;
			alarms.append(alarm);
		}
		if(it_vehicle->second->status_power == STATUS_ERROR){
			Json::Value alarm;
			AlarmTypeMap::iterator it_alarm = mp_alarm_type_list.find(ATID_POWER);
			if(it_alarm != mp_alarm_type_list.end()){
				alarm[JSON_KEY_ALARM_TYPE_NAME] = it_alarm->second;
			}
			localtime_s(&local_time, &it_vehicle->second->time_low_power);
			strftime(_time, STR_LEN_TIME, "%Y-%m-%d %H:%M:%S", &local_time);
			alarm[JSON_KEY_ALARM_START_TIME] = _time;
			alarms.append(alarm);
		}
		if(it_vehicle->second->status_over_speed == STATUS_ERROR){
			Json::Value alarm;
			AlarmTypeMap::iterator it_alarm = mp_alarm_type_list.find(ATID_OVER_SPEED);
			if(it_alarm != mp_alarm_type_list.end()){
				alarm[JSON_KEY_ALARM_TYPE_NAME] = it_alarm->second;
			}
			localtime_s(&local_time, &it_vehicle->second->time_over_speed);
			strftime(_time, STR_LEN_TIME, "%Y-%m-%d %H:%M:%S", &local_time);
			alarm[JSON_KEY_ALARM_START_TIME] = _time;
			alarms.append(alarm);
		}
		if(alarms != NULL){
			vehichle[JSON_KEY_ALARM_STAFFER_ID] = it_vehicle->second->id;
			vehichle[JSON_KEY_ALARM_ALARMS] = alarms;
			_vehicle.append(vehichle);
		}
	}

	if(_global != NULL){
		data[JSON_KEY_ALARM_GLOBAL] = _global;
	}
	if(_areas != NULL){
		data[JSON_KEY_ALARM_AREA] = _areas;
	}
	if(_readers != NULL){
		data[JSON_KEY_ALARM_READER] = _readers;
	}
	if(_staff != NULL){
		data[JSON_KEY_ALARM_STAFF] = _staff;
	}
	if(_vehicle != NULL){
		data[JSON_KEY_ALARM_VEHICLE] = _vehicle;
	}
	if(data != NULL){
		root[JSON_ROOT_KEY_CMD] = JSON_CMD_VALUE_ALARM;
		root[JSON_ROOT_KEY_DATA] = data;
		return root.toFastString();
	}
	return "";	
}

std::string CYAServerDlg::get_json_postion()
{
	Json::Value root;
	Json::Value pos_map;
	Json::Value pos_maps;
	char _time[STR_LEN_TIME];
	struct tm local_time;
	Json::Value pos_card;

	MapInfoMap::iterator it_map = mp_map_list.begin();
	for(; it_map != mp_map_list.end(); ++it_map){
		Json::Value pos_cards;
		CardMap::iterator it = mp_card_list_all.begin();
		for(; it != mp_card_list_all.end(); ++it){
			/*if(!it->second->is_hist){
			if(it->second->pos_state != DT_DOWN){
			continue;
			}
			if(it->second->issent) {
			continue;
			}
			if(it->second->map_id != it_map->second->map_id){
			continue;
			}
			if(!it->second->isdealed){
			continue;
			}
			}*/
			it->second->isdealed = false;
			it->second->issent = true;
			pos_card[JSON_KEY_CARD_ID] = it->second->card_id;
			pos_card[JSON_KEY_CARD_TYPE_ID] = it->second->card_type;
			pos_card[JSON_KEY_CARD_NUM] = it->second->number;

			localtime_s(&local_time, &it->second->down_time);
			strftime(_time, STR_LEN_TIME, "%Y-%m-%d %H:%M:%S", &local_time);
			pos_card[JSON_KEY_DOWN_TIME] = _time;

			pos_card[JSON_KEY_WORK_TIME] = CFunctions::getworktimebysec((int)difftime(time(NULL), it->second->down_time));
			localtime_s(&local_time, &it->second->enter_area_time);
			strftime(_time, STR_LEN_TIME, "%Y-%m-%d %H:%M:%S", &local_time);
			pos_card[JSON_KEY_ENTER_AREA_TIME] = _time;

			pos_card[JSON_KEY_AREA_ID] = it->second->area_id;
			pos_card[JSON_KEY_STATE_DESC] = it->second->get_state_text(); 
			pos_card[JSON_KEY_STATE] = it->second->state;
			pos_card[JSON_KEY_MOVING_STATE] = it->second->get_acc_text();

			//ctime_s(_time, 30, &(it->second->rev_time));
			//struct tm *local_time = NULL;
			localtime_s(&local_time, &it->second->rec_time);
			//local_time = localtime(&it->second->rev_time);
			strftime(_time, 30, "%Y-%m-%d %H:%M:%S", &local_time);
			//strftime(_time, STR_LEN_TIME, "%Y-%m-%d %H:%M:%S", localtime(&it->second->rev_time));
			pos_card[JSON_KEY_REC_TIME] = _time;

			pos_card[JSON_KEY_CORDINATE_X] = CFunctions::round(it->second->x, 2);
			pos_card[JSON_KEY_CORDINATE_Y] = CFunctions::round(it->second->y, 2);
			pos_card[JSON_KEY_CORDINATE_Z] =  0;// it->second->z;
			pos_card[JSON_KEY_AREA_ID] = it->second->area_id;
			pos_card[JSON_KEY_DEPT_ID] = it->second->dept_id;
			pos_card[JSON_KEY_MAP_ID] = it->second->map_id;
			pos_card[JSON_KEY_SPEED] = it->second->v;
			//localtime_s(&local_time, &it->second->up_time);
			//strftime(_time, STR_LEN_TIME, "%Y-%m-%d %H:%M:%S", &local_time);
			//pos_card[JSON_KEY_UP_TIME] = _time;
			//localtime_s(&local_time, &it->second->enter_reader_time);
			//strftime(_time, STR_LEN_TIME, "%Y-%m-%d %H:%M:%S", &local_time);
			//pos_card[JSON_KEY_ENTER_READER_TIME] = _time;			
			//pos_card[JSON_KEY_MAP_ID] = it->second->p_reader->map_id;
			pos_cards.append(pos_card);	
		}
		if(!pos_cards.isNull()){
			pos_map[JSON_KEY_MAP_ID] = it_map->second->map_id;
			pos_map[JSON_KEY_POS_CARD] = pos_cards;
			pos_maps.append(pos_map);
		}
	}
	std::string ret = "";
	if(! pos_maps.isNull()){
		root[JSON_ROOT_KEY_CMD] = JSON_CMD_VALUE_POS_MAP;
		root[JSON_ROOT_KEY_DATA] = pos_maps;
		root[JSON_ROOT_KEY_DIFF_TICK_COUNT] = (int)g_diffTickCount;
		ret = root.toFastString();
	}
	return ret;
}

std::string CYAServerDlg::get_json_postion_all()
{
	Json::Value root;
	Json::Value pos_map;
	Json::Value pos_maps;
	Json::Value pos_card;
	char _time[STR_LEN_TIME];
	struct tm local_time;
	MapInfoMap::iterator it_map = mp_map_list.begin();
	for(; it_map != mp_map_list.end(); ++it_map){
		Json::Value pos_cards;
		CardMap::iterator it = mp_card_list_all.begin();
		for(; it != mp_card_list_all.end(); ++it){
			if(it->second->map_id != it_map->second->map_id){
				continue;
			}			
			it->second->issent = true;
			pos_card[JSON_KEY_CARD_ID] = it->second->card_id;
			pos_card[JSON_KEY_CARD_TYPE_ID] = it->second->card_type;
			pos_card[JSON_KEY_CARD_NUM] = it->second->id;

			localtime_s(&local_time, &it->second->down_time);
			strftime(_time, STR_LEN_TIME, "%Y-%m-%d %H:%M:%S", &local_time);
			pos_card[JSON_KEY_DOWN_TIME] = _time;

			pos_card[JSON_KEY_WORK_TIME] = CFunctions::getworktimebysec((int)difftime(time(NULL), it->second->down_time));
			localtime_s(&local_time, &it->second->enter_area_time);
			strftime(_time, STR_LEN_TIME, "%Y-%m-%d %H:%M:%S", &local_time);
			pos_card[JSON_KEY_ENTER_AREA_TIME] = _time;

			pos_card[JSON_KEY_AREA_ID] = it->second->area_id;
			pos_card[JSON_KEY_STATE] = it->second->state;

			localtime_s(&local_time, &it->second->rec_time);
			strftime(_time, STR_LEN_TIME, "%Y-%m-%d %H:%M:%S", &local_time);
			pos_card[JSON_KEY_REC_TIME] = _time;

			pos_card[JSON_KEY_CORDINATE_X] = it->second->x;
			pos_card[JSON_KEY_CORDINATE_Y] = it->second->y;
			pos_card[JSON_KEY_CORDINATE_Z] = 0; //it->second->z;
			pos_card[JSON_KEY_AREA_ID] = it->second->area_id;
			pos_card[JSON_KEY_DEPT_ID] = it->second->dept_id;
			pos_card[JSON_KEY_MAP_ID] = it->second->map_id;
			pos_card[JSON_KEY_SPEED] = it->second->v;

			pos_cards.append(pos_card);			
		}
		pos_map[JSON_KEY_MAP_ID] = it_map->second->map_id;
		pos_map[JSON_KEY_POS_CARD] = pos_cards;
		pos_maps.append(pos_map);
	}
	root[JSON_ROOT_KEY_CMD] = JSON_CMD_VALUE_POS_MAP;
	root[JSON_ROOT_KEY_DATA] = pos_maps;
	return root.toFastString();
}

//std::string CYAServerDlg::get_json_postion_test()
//{
//	Json::Value root;
//	Json::Value valStaffer;
//	Json::Value valStaffers;
//	Json::Value valDist;
//	Json::Value valDists;
//	Json::Value valReaders;
//	Json::Value valReader;
//	int nCnt = 0;
//	std::string strJson;
//	for(CardMap::iterator it = mp_card_list_all.begin(); it != mp_card_list_all.end(); ++it){
//		if(!it->second->isreceive) continue;
//		it->second->isreceive = false;
//		valStaffer["id"] = it->second->card_id;
//		valStaffer["x"] = it->second->x;
//		valStaffer["y"] = it->second->y;
//		int n = it->second->get_effictive_dist_count();
//		for(int i=0; i < n; i++){
//			valDist["reader_id"] = it->second->p_dists[i]->reader_id;
//			valDist["dist"] = (int)it->second->p_dists[i]->d;
//			valDist["x"] = (int)it->second->p_dists[i]->x;
//			valDist["y"] = (int)it->second->p_dists[i]->y;		
//			valDists.append(valDist);
//		}
//		valStaffer["dists"] = valDists;
//		valStaffers.append(valStaffer);
//		nCnt++;		
//	}
//
//	root["staffer"] = valStaffers;
//
//	ReaderMap::iterator itReader = mp_reader_list.begin();
//	for(; itReader != mp_reader_list.end(); ++itReader)
//	{
//		valReader["id"] = itReader->second->reader_id;
//		valReader["x"] = itReader->second->reader_x;
//		valReader["y"] = itReader->second->reader_y;
//		valReaders.append(valReader);
//	}
//
//	root["reader"] = valReaders;
//
//	if(nCnt == 0)
//		return "";
//	strJson = root.toFastString();
//	return strJson;
//}

std::string CYAServerDlg::get_json_login()
{
	Json::Value root;
	Json::Value data;
	data[JSON_KEY_USERNAME] = JSON_VALUE_USERNAME;
	data[JSON_KEY_PASSWORD] = JSON_VALUE_PASSWORD;
	root[JSON_ROOT_KEY_CMD] =  JSON_CMD_VALUE_LOGIN;
	root[JSON_ROOT_KEY_DATA] = data;
	return root.toFastString();
}

std::string CYAServerDlg::get_json_logout()
{
	Json::Value root;
	Json::Value data;
	//data[JSON_KEY_USERNAME] = JSON_VALUE_USERNAME;
	data["name"] = JSON_VALUE_USERNAME;
	root[JSON_ROOT_KEY_CMD] =  JSON_CMD_VALUE_LOGOUT;
	//root[JSON_ROOT_KEY_DATA] = data;
	root["user"] = data;
	return root.toFastString();
}

//std::string CYAServerDlg::get_json_down_mine(Card* card)
//{
//
//	return "";
//}
//
//std::string CYAServerDlg::get_json_up_mine(Card* card)
//{
//	return "";
//}

void CYAServerDlg::send_json_data(string cmd, string data, bool is_login /* = false*/)
{
	DWORD dw, dw1;
	USES_CONVERSION;
	CC2UTF8 conv = (char*)data.c_str();
	string utf8_data = conv.c_str();
	CString strlog;
	if(is_login){
		if(is_websocket_ok){
			_io->socket()->emit(cmd, utf8_data);
			is_websocket_login = true;
			strlog.Format(_T("%s: %s"), _T(LOG_SEND_JSON_DATA), _T("登录数据"));
			show_log(strlog);
		}
	}else if(is_websocket_login){
		strlog.Format(_T("%s: %s"), _T(LOG_SEND_JSON_DATA), _T("常规数据"));
		show_log(strlog);
		_io->socket()->emit(cmd, utf8_data);
		if(theApp.log_send_event){
			writeErrorLog(L"JSON_S", CFunctions::c2wc(data.c_str()));
		}
	}
	//strlog.Format(_T("%s: %s"), _T(LOG_SEND_JSON_DATA), CFunctions::c2wc(cmd.c_str()));
	//show_log(strlog);
	dw = GetTickCount();
	g_diffTickCount = dw - g_tickcount;
	TRACE(_T("%d\r\n"), dw - g_tickcount );
	g_tickcount = dw;

}

// 处理分站状态
void CYAServerDlg::deal_readers()
{
	ReaderMap::iterator it = mp_reader_list.begin();
	for(; it != mp_reader_list.end(); ++ it){
		int ndiff = (int)difftime(time(NULL), it->second->rec_time);
		if(STATUS_DEVICE_ERROR == it->second->state){ // 异常 
			if(ndiff < READER_TIMEOUT){ // 恢复正常
				store_data_reader(it->second, ALARM_READER_LOST_END);
				it->second->state = STATUS_DEVICE_NORMAL;
			}
		}else{
			if(ndiff >= READER_TIMEOUT){ //异常
				it->second->state = STATUS_DEVICE_ERROR;
				it->second->lost_time = time(NULL);
				store_data_reader(it->second, ALARM_READER_LOST_START);
			}
		}
	}
}

void CYAServerDlg::deal_areas()
{
	// 区域人数，区域超员数，区域超时数
	int count_person, count_vehicle, count_total, count_over_time_person, count_over_time_vehicle;
	int over_time_vehicle, over_time_person, over_time;
	time_t current_time(time(NULL));
	AreaMap::iterator it_Area = mp_area_list.begin();
	bool is_true;
	for(; it_Area != mp_area_list.end(); ++it_Area){
		count_person = count_vehicle = count_total = count_over_time_vehicle = count_over_time_person = 0;
		over_time_person = it_Area->second->over_time_person * 60; // 转为秒
		over_time_vehicle = it_Area->second->over_time_vehicle * 60; // 转为秒

		over_time = over_time_person;
		// 遍历卡，计数
		CardMap::iterator it_card_person = it_Area->second->area_card_list_person.begin();
		for(; it_card_person != it_Area->second->area_card_list_person.end(); ++it_card_person){
			// 计数
			count_total++;
			count_person++;
			// 超时
			is_true = difftime(current_time, it_card_person->second->enter_area_time) > over_time;
			if(is_true){
				if(!it_card_person->second->is_area_over_time){
					it_card_person->second->is_area_over_time = true;
					it_card_person->second->time_area_over_time = current_time;
					store_data_card(it_card_person->second, ALARM_CARD_OVER_TIME_AREA_START);
					deal_alarm_card(it_card_person->second, &mp_card_list_area_over_time_person, is_true, AF_CARD_AREA_OVER_TIME);
				}
				over_time_person++;
			}else if(it_card_person->second->is_area_over_time){ // 理论上不会走这条分支，应该走cards_leave_area()
				it_card_person->second->is_area_over_time = false;
				deal_alarm_card(it_card_person->second, &mp_card_list_area_over_time_person, is_true, AF_CARD_AREA_OVER_TIME);
			}				
		}
		over_time = over_time_vehicle;
		CardMap::iterator it_card_vehicle = it_Area->second->area_card_list_vehicle.begin();
		for(;it_card_vehicle != it_Area->second->area_card_list_vehicle.end(); ++it_card_vehicle){
			// 计数
			count_total++;
			// 区域超速,暂无此逻辑
			count_vehicle++;
			// 超时
			if(difftime(current_time, it_card_vehicle->second->enter_area_time) > over_time){
				if(!it_card_vehicle->second->is_area_over_time){
					it_card_vehicle->second->is_area_over_time = true;
					it_card_vehicle->second->time_area_over_time = current_time;
					store_data_card(it_card_person->second, ALARM_CARD_OVER_TIME_AREA_START);
					deal_alarm_card(it_card_vehicle->second, &mp_card_list_area_over_time_vehicle, is_true, AF_CARD_AREA_OVER_TIME);
				}
				over_time_vehicle++;
			}else if(it_card_vehicle->second->is_area_over_time){ // 理论上不会走这条分支，应该走cards_leave_area()
				it_card_vehicle->second->is_area_over_time = false;
				deal_alarm_card(it_card_vehicle->second, &mp_card_list_area_over_time_vehicle, is_true, AF_CARD_AREA_OVER_TIME);
			}				
		}
		it_Area->second->count_person = count_person;
		it_Area->second->count_vehicle = count_vehicle;
		it_Area->second->count_area_over_time_person = count_over_time_person;
		it_Area->second->count_area_over_time_vehicle = count_over_time_vehicle;
		// 区域禁入 人员
		if(it_Area->second->over_count_person == 0){
			if(count_person > 0){
				if(!it_Area->second->is_area_forbidden_person){
					it_Area->second->is_area_forbidden_person = true;
					it_Area->second->count_area_forbidden_person = count_person;
					it_Area->second->time_forbidden_person = current_time;
					store_data_area(it_Area->second, current_time, current_time, ALARM_AREA_FORBIDDEN_PERSON_START);
					deal_alarm_area(it_Area->second, &mp_area_forbidden_person, true, AF_AREA_FORBIDDEN);
				}
			}else{
				if(it_Area->second->is_area_forbidden_person){
					it_Area->second->is_area_forbidden_person = false; // 结束报警
					store_data_area(it_Area->second, current_time, it_Area->second->time_forbidden_person, ALARM_AREA_FORBIDDEN_PERSON_END);
					deal_alarm_area(it_Area->second, &mp_area_forbidden_person, false, AF_AREA_FORBIDDEN);
				}
			}
		} else {
			if(count_person > it_Area->second->over_count_person ){ // 区域人员超员
				if(!it_Area->second->is_area_over_count_person){
					it_Area->second->is_area_over_count_person = true;
					it_Area->second->count_area_over_count_person = count_person - it_Area->second->over_count_person;
					it_Area->second->time_over_count_person = current_time;
					store_data_area(it_Area->second, current_time, current_time, ALARM_AREA_OVER_COUNT_PERSON_START);
					deal_alarm_area(it_Area->second, &mp_area_over_count_person, true, AF_AREA_OVER_COUNT);
				}
			}else{
				if(it_Area->second->is_area_over_count_person){ // 结束超员
					it_Area->second->is_area_over_count_person = false;
					store_data_area(it_Area->second, current_time, it_Area->second->time_over_count_person, ALARM_AREA_OVER_COUNT_PERSON_END);
					deal_alarm_area(it_Area->second, &mp_area_over_count_person, false, AF_AREA_OVER_COUNT);
				}
			}
			// 区域人员超时
			if(count_over_time_person > 0){
				if(!it_Area->second->is_area_over_time_person){
					it_Area->second->is_area_over_time_person = true;
					it_Area->second->time_over_time_person = current_time;
					deal_alarm_area(it_Area->second, &mp_area_over_time_person, true, AF_AREA_OVER_TIME);
				}			
			}else{
				if(it_Area->second->is_area_over_time_person){ // 结束
					it_Area->second->is_area_over_time_person = false;
					deal_alarm_area(it_Area->second, &mp_area_over_time_person, false, AF_AREA_OVER_TIME);
				}
			}
		}
		// 区域禁入 车辆
		if(it_Area->second->over_count_vehicle == 0){
			if(count_vehicle > 0){
				if(!it_Area->second->is_area_forbidden_vehicle){
					it_Area->second->is_area_forbidden_vehicle = true;
					it_Area->second->count_area_forbidden_vehicle = count_vehicle;
					it_Area->second->time_forbidden_vehicle = current_time;
					store_data_area(it_Area->second, current_time, current_time, ALARM_AREA_FORBIDDEN_VEHICLE_START);
					deal_alarm_area(it_Area->second, &mp_area_forbidden_vehicle, true, AF_AREA_FORBIDDEN);
				}
			}else{
				if(it_Area->second->is_area_forbidden_vehicle){
					it_Area->second->is_area_forbidden_vehicle = false; // 结束报警
					store_data_area(it_Area->second, current_time, it_Area->second->time_forbidden_vehicle, ALARM_AREA_FORBIDDEN_VEHICLE_END);
					deal_alarm_area(it_Area->second, &mp_area_forbidden_vehicle, false, AF_AREA_FORBIDDEN);
				}
			}
		}else {
			if(count_vehicle > it_Area->second->over_count_vehicle){  // 区域车辆超员
				if(!it_Area->second->is_area_over_count_vehicle){
					it_Area->second->is_area_over_count_vehicle = true;
					it_Area->second->count_area_over_count_vehicle = count_vehicle - it_Area->second->over_count_vehicle;
					it_Area->second->time_over_count_vehicle = current_time;
					store_data_area(it_Area->second, current_time, current_time, ALARM_AREA_OVER_COUNT_VEHICLE_START);
					deal_alarm_area(it_Area->second, &mp_area_over_count_vehicle, true, AF_AREA_OVER_COUNT);
				}
			}else{
				it_Area->second->is_area_over_count_vehicle = false; // 结束
				store_data_area(it_Area->second, current_time, it_Area->second->time_over_count_vehicle, ALARM_AREA_OVER_COUNT_VEHICLE_END);
				deal_alarm_area(it_Area->second, &mp_area_over_count_vehicle, false, AF_AREA_OVER_COUNT);
			}		
			// 区域车辆超时
			if(count_over_time_vehicle > 0){
				if(!it_Area->second->is_area_over_time_vehicle){
					it_Area->second->is_area_over_time_vehicle = true;
					it_Area->second->time_over_time_vehicle = current_time;
					deal_alarm_area(it_Area->second, &mp_area_over_time_vehicle, true, AF_AREA_OVER_TIME);
				}
			}else{
				if(it_Area->second->is_area_over_time_vehicle){ // 结束
					it_Area->second->is_area_over_time_vehicle = false;
					deal_alarm_area(it_Area->second, &mp_area_over_time_vehicle, false, AF_AREA_OVER_TIME);
					// 写入数据库
				}
			}
		}
	}
}

void CYAServerDlg::deal_card( Card* card, bool is_hist )
{
	if(!is_hist){
		if(card->card_type == CT_ADHOC){ // 此处不需处理，已经在解析时计算了坐标位置			

		}else if( LT_READER == theApp.locate_type){
			card->x = card->p_reader->ant[card->antenna_id]->antenna_x;
			card->y = card->p_reader->ant[card->antenna_id]->antenna_y;
			card->z = card->p_reader->ant[card->antenna_id]->antenna_z;
			card->a = card->p_reader->ant[card->antenna_id]->antenna_angle;
			card->reader_id = card->p_reader->reader_id;
		}else{
			// 将距离加入到距离列表
			_coordinate* dist = new _coordinate;
			dist->t = card->time_stamp;
			dist->x = card->p_reader->ant[card->antenna_id]->antenna_x;
			dist->y = card->p_reader->ant[card->antenna_id]->antenna_y;
			dist->z = card->p_reader->ant[card->antenna_id]->antenna_z;
			dist->a = card->p_reader->ant[card->antenna_id]->antenna_angle;
			dist->reader_id = card->p_reader->reader_id;
			dist->antenna_id = card->antenna_id;
			dist->d = card->distance;
			dist->v = 0;
			dist->d_offset = 0;
			HostServer::TagMsg tagMsg;
			tagMsg.ReceiveTime = card->flying_time;
			tagMsg.StationIdCode = HostServer::SyncHelper::parseId((unsigned long long)card->reader_id, (unsigned long long)(card->antenna_id + 1));
			tagMsg.SyncNum = card->sync_num;
			if(card->p_reader->sync_level == 0){
				dist->tt = card->flying_time;
			}else{
				dist->tt = syncmanager.calTimeByLinar(tagMsg);
			}

			card->add_dist(dist);
			CString strLog;

			if(card->x != card->last_x || card->y != card->last_y){
				strLog.Format(_T("cx: %f, cy: %f, cz: %f, clx: %f, cly: %f"), card->x, card->y, card->z, card->last_x, card->last_y);
				writeErrorLog(_T("DIST_S"), strLog, true);
			}

			//strLog.Format(_T("r: %d-%d, t: %d, d: %f, x1: %f, y1: %f, z1: %f, rd: %f"),
			//	dist->reader_id, dist->antenna_id + 1, dist->t, dist->d, dist->x, dist->y, dist->z, dist->d /card->map_scale);
			//writeErrorLog(_T("DIST_S"), strLog, false);
			strLog.Format(_T("r: %d-%d, t: %d, l:%d, tt: %I64u, ft: %I64u, x1: %f, y1: %f, z1: %f, ct: %d"),
				dist->reader_id, dist->antenna_id + 1, card->sync_num, card->p_reader->sync_level, dist->tt, card->flying_time,  dist->x, dist->y, dist->z,card->time_stamp);
			writeErrorLog(_T("DIST_S"), strLog, true);

			//// 计算坐标
			//int nCount = card->get_effictive_dist_count();
			//if(nCount < 4) return;
			//card->get_coordinate(nCount);
		}
	}
	if(LT_READER == theApp.locate_type){
		time_t cur_time = time(NULL);
		if(difftime(cur_time, card->deal_time) <30){
			return ;
		}
	}
	card->deal_time = time(NULL);

	//if(nCount > 1){
	//	CString strTemp, strLog;
	//	for(int i = 0; i < nCount; i++){
	//		strTemp.Format(_T("%.4f, %.4f, %.4f, %.4f, %.2f\n"), card->p_dists_locate[i]->x, card->p_dists_locate[i]->y,
	//			card->p_dists_locate[i]->z, card->p_dists_locate[i]->d, card->p_dists_locate[i]->a);
	//		strLog += strTemp;
	//	}
	//	strTemp.Format(_T("%.4f, %.4f"), card->x, card->y);
	//	strLog += strTemp;
	//	writeErrorLog(_T("D"), strLog);
	//}
	save_card_postion(card);
	card_enter_map(card); // 切换地图
	card_enter_area(card); //, card->deal_time);
	deal_card_state(card);
	card->isdealed = true;
	if(LT_READER != theApp.locate_type){
		card->issent = false;
	}
}

void CYAServerDlg::card_enter_mine( Card* card )
{
	if(!card->is_pos_state_changed(TEST_CONFIRM_COUNT)){ // 位置没有变化
		if(DT_DOWN == card->pos_state){
			if(CT_PERSON == card->card_type){
				if(difftime(time(NULL), card->get_working_time()) > sls_setting.over_time_person){
					store_data_card(card, ALARM_CARD_OVER_TIME_START);
					deal_alarm_card(card, &mp_card_list_over_time_person, true,  AF_CARD_OVER_TIME);
				}
			}else if(CT_VEHICLE == card->card_type){
				if(difftime(time(NULL), card->get_working_time()) > sls_setting.over_time_vehicle){
					store_data_card(card, ALARM_CARD_OVER_TIME_START);
					deal_alarm_card(card, &mp_card_list_over_time_vehicle, true, AF_CARD_OVER_TIME);
				}
				if(card->get_speed() > sls_setting.over_speed){
					store_data_card(card, ALARM_CARD_OVER_SPEED_START);
					deal_alarm_card(card, &mp_card_list_over_speed_vehicle, true, AF_CARD_OVER_SPEED);
				}
			}
		}
	}else{
		if(DT_UP == card->pos_state){ // 升井
			card_up_mine(card);
			// 升井，补全离开区域时间
			store_data_card(card, HIS_AREA_LOCATION_LEAVE);
		}else if(DT_DOWN == card->pos_state){ // 入井
			card_down_mine(card);
		}
		send_json_data(JSON_CMD_VALUE_PUSH, get_json_down_and_up(card));
	}
}

void CYAServerDlg::card_enter_park( Card* card )
{

}

void CYAServerDlg::card_enter_map( Card* card )
{
	if(card->map_id == card->map_id_old) return ;
	// 离开原地图，进入新地图
	MapInfoMap::iterator it_map_old = mp_map_list.find(card->map_id_old);
	if(it_map_old != mp_map_list.end()){
		if(CT_PERSON == card->card_type){
			CardMap::iterator it_card = it_map_old->second->map_card_list_person.find(card->card_id);
			if(it_card != it_map_old->second->map_card_list_person.end()){
				it_map_old->second->map_card_list_person.erase(it_card);
			}
		}else if(CT_VEHICLE == card->card_type){
			CardMap::iterator it_card = it_map_old->second->map_card_list_vehicle.find(card->card_id);
			if(it_card != it_map_old->second->map_card_list_vehicle.end()){
				it_map_old->second->map_card_list_vehicle.erase(it_card);
			}
		}
	}
	card->map_id_old = card->map_id;
	MapInfoMap::iterator it_map = mp_map_list.find(card->map_id);
	if(it_map != mp_map_list.end()){
		card->map_scale = it_map->second->map_scale;
		if(CT_PERSON == card->card_type){
			it_map->second->map_card_list_person.insert(make_pair(card->card_id, card));
		}else  if(CT_VEHICLE == card->card_type){
			it_map->second->map_card_list_vehicle.insert(make_pair(card->card_id, card));
		}
	}
}

void CYAServerDlg::card_enter_area( Card* card)
{
	_point p1, p2;
	double r, scale;
	bool b_in_area = false;
	p1.x = card->x, p1.y = card->y, p1.z = card->z;
	AreaMap::iterator it_area_cur = mp_area_list.find(card->area_id);
	if(it_area_cur != mp_area_list.end()){ // 在区域中 
		if(it_area_cur->second->is_in_polygon(p1)) { // 区域没有变化
			return;
		}
		//else{
		//	// 离开区域
		//	store_data_card(card, HIS_AREA_LOCATION_LEAVE);
		//	card_leave_area(card, it_area_cur->second);
		//}
	}
	int old_area_id = card->area_id;
	AreaMap::iterator it_area = mp_area_list.begin();
	for(; it_area != mp_area_list.end(); ++it_area){
		if(card->map_id == it_area->second->map_id){ // 必须在同一地图内
			if(it_area->second->is_in_polygon(p1)){ // 在区域内
				if(it_area_cur != mp_area_list.end()){ // 离开区域
					store_data_card(card, HIS_AREA_LOCATION_LEAVE);
					card_leave_area(card, it_area_cur->second);
				}
				card->area_id = it_area->second->area_id;
				card->enter_area_time = card->deal_time;
				card->pos_state = (0 == it_area->second->area_type_id) ? DT_UP :DT_DOWN;
				if(CT_PERSON == card->card_type){
					it_area->second->area_card_list_person.insert(make_pair(card->card_id, card));
					if(it_area->second->over_count_person == 0){
						store_data_card(card, ALARM_CARD_AREA_FORBIDDEN_START);
						deal_alarm_card(card, &mp_card_list_forbidden_person, true, AF_CARD_AREA_FORBIDDEN);
					}
				}else if(CT_VEHICLE == card->card_type){
					it_area->second->area_card_list_vehicle.insert(make_pair(card->card_id, card));
					if(it_area->second->over_count_vehicle == 0){
						store_data_card(card, ALARM_CARD_AREA_FORBIDDEN_START);
						deal_alarm_card(card, &mp_card_list_forbidden_vehicle, true, AF_CARD_AREA_FORBIDDEN);
					}
				}
				b_in_area = true;
				break;
			}
		}
	}

	if(!b_in_area){ // 找不到区域，使用分站所属区域
		AreaMap::iterator it_area_reader = mp_area_list.find(card->p_reader->map_id);
		if(it_area_reader != mp_area_list.end()){
			if(card->area_id != it_area_reader->second->area_id){
				if(it_area_cur != mp_area_list.end()){
					store_data_card(card, HIS_AREA_LOCATION_LEAVE);
					card_leave_area(card, it_area_cur->second);
				}
				card->area_id = it_area_reader->second->area_id;
				card->enter_area_time = card->deal_time;
				card->pos_state = (0 == it_area_reader->second->area_type_id) ? DT_UP :DT_DOWN;
				if(CT_PERSON == card->card_type){
					it_area_reader->second->area_card_list_person.insert(make_pair(card->card_id, card));
					if(it_area_reader->second->over_count_person == 0){
						store_data_card(card, ALARM_CARD_AREA_FORBIDDEN_START);
						deal_alarm_card(card, &mp_card_list_forbidden_person, true, AF_CARD_AREA_FORBIDDEN);
					}
				}else if(CT_VEHICLE == card->card_type){
					it_area_reader->second->area_card_list_vehicle.insert(make_pair(card->card_id, card));
					if(it_area_reader->second->over_count_vehicle == 0){
						store_data_card(card, ALARM_CARD_AREA_FORBIDDEN_START);
						deal_alarm_card(card, &mp_card_list_forbidden_vehicle, true, AF_CARD_AREA_FORBIDDEN);
					}
				}
			}
		}
	}
	// 保存区域信息
	store_data_card(card, HIS_AREA_LOCATION_ENTER);
	// 升入井判断
	card_enter_mine(card);
}

void CYAServerDlg::card_leave_area( Card* card, Area* area)
{
	// 从列表中删除
	CardMap *card_map, *alarm_card_map, *alarm_forbidden_map;
	if(CT_PERSON == card->card_type){
		card_map = &area->area_card_list_person;
		alarm_card_map = &mp_card_list_area_over_time_person;
		alarm_forbidden_map = &mp_card_list_forbidden_person;
	}else if(CT_VEHICLE == card->card_type){
		card_map = &area->area_card_list_vehicle;
		alarm_card_map = &mp_card_list_area_over_time_vehicle;
		alarm_forbidden_map = &mp_card_list_forbidden_vehicle;
	}
	CardMap::iterator it_card = card_map->find(card->card_id);
	if(it_card != card_map->end()){
		// 如果区域超时
		if(it_card->second->is_area_over_time){
			it_card->second->is_area_over_time = false;
			store_data_card(card, ALARM_CARD_OVER_TIME_AREA_END);
			deal_alarm_card(card, alarm_card_map, false, AF_CARD_AREA_OVER_TIME);
		}
		store_data_card(card, ALARM_CARD_AREA_FORBIDDEN_END);
		deal_alarm_card(card, alarm_forbidden_map, false, AF_CARD_AREA_FORBIDDEN);
		// 先处理，后删除
		card_map->erase(it_card);
	}
}

void CYAServerDlg::reset_map_card()
{
	MapInfoMap::iterator it_map = mp_map_list.begin();
	for(; it_map != mp_map_list.end(); ++ it_map){
		//用map.erase(map.begin(),map.end())比较好  清空元素
		it_map->second->map_card_list_person.erase(it_map->second->map_card_list_person.begin(), it_map->second->map_card_list_person.end());
		it_map->second->map_card_list_vehicle.erase(it_map->second->map_card_list_vehicle.begin(), it_map->second->map_card_list_vehicle.end());
		//it_map->second->map_card_list.clear(); // 删除map
	}
}

bool CYAServerDlg::is_in_rectangle( _point p, double dblleft, double dbltop, double dblright, double dblbottom )
{
	return (p.x >= dblleft && p.x <= dblright && p.y >= dbltop && p.y <= dblbottom);
}

bool CYAServerDlg::is_in_circle( _point p1, _point p2, double r, double scale )
{
	return sqrt((p2.x - p1.x) * (p2.x - p1.x) +  (p2.y - p1.y) * (p2.y - p1.y)) <= r * scale;
}

void CYAServerDlg::package_data()
{
	string strJson = get_json_postion(); // get_json_postion_test();
	// 定位数据
	if(strJson == "") return ;
	send_json_data(JSON_CMD_VALUE_PUSH, strJson);
	dw_last_send_time = GetTickCount();
	//ifstream

	//json字符串输出到文件中
	/*ofstream ofs;
	ofs.open("result.js",ios::app);
	Json::StyledWriter writer;
	string res = writer.write(strJson);
	ofs << res;
	ofs.close();*/
}

void CYAServerDlg::package_data_test()
{
	Json::Value root;
	Json::Value valStaffer;
	Json::Value valStaffers;
	Json::Value valDistance;
	Json::Value valDist;
	Json::Value valReaders;
	Json::Value valReader;
	int nCnt = 0;
	std::string strJson;
	for(int i = 1; i < 4; i++){
		valStaffer["id"] = i;
		valStaffer["x"] = 50 * (m_nCountClick + i);
		valStaffer["y"] = 50 * sin(20.0) * (m_nCountClick + i);
		valStaffers.append(valStaffer);
		nCnt++;
	}
	root["staffer"] = valStaffers;
	//map<DWORD, READERINFO*>::iterator itReader = m_mpReaderInfo.begin();
	//for(; itReader != m_mpReaderInfo.end(); ++itReader)
	//{
	//	valReader["id"] = (unsigned int)itReader->second->readerid;
	//	valReader["x"] = itReader->second->X;
	//	valReader["y"] = itReader->second->Y;

	//	valReaders.append(valReader);
	//}
	root["reader"] = valReaders;
	if(nCnt == 0){
		return;
	}
	strJson = root.toFastString();
	send_json_data(JSON_CMD_VALUE_PUSH, strJson.c_str());
}

void CYAServerDlg::formatByteArray( CString &strBuf, BYTE * buf, int nLen )
{
	CString strBuf1 = _T("");
	for(int i = 0; i < nLen; i++){
		strBuf1.Format(_T("%.2X "),buf[i]);
		strBuf += strBuf1;
		if((i + 1) % 16 == 0){
			strBuf += _T("\n");
		}
	}
}

void CYAServerDlg::writeErrorLog( const CString strFile, const CString strErr, bool bTime /*= true*/  )
{
	EnterCriticalSection(&m_csWriteLog);
	if(openLogFile(strFile)){
		CString strTempInfo;
		if(bTime){
			COleDateTime t = COleDateTime::GetCurrentTime(); 
			strTempInfo.Format(_T("%s\r\n%s\r\n"), t.Format(_T("%H:%M:%S")), strErr);
		}else{
			strTempInfo.Format(_T("%s\r\n"), strErr);
		}
		TRY{
			cfErrorLog.SeekToEnd();
			char* old_locale = _strdup(setlocale(LC_CTYPE,NULL));
			setlocale( LC_CTYPE, "chs" );//设定

			cfErrorLog.WriteString(strTempInfo);

			setlocale( LC_CTYPE, old_locale );
			free( old_locale );//还原区域设定
		}
		CATCH(CFileException, e){
			if(cfErrorLog.m_pStream)
				cfErrorLog.Close();
			return;
		}
		END_CATCH
	}
	LeaveCriticalSection(&m_csWriteLog);
}

BOOL CYAServerDlg::openLogFile(CString strFile)
{
	TCHAR lpstrCurDir[MAX_PATH] = _T("");
	CString ctemp;
	GetModuleFileName(NULL,lpstrCurDir,MAX_PATH);
	ctemp = lpstrCurDir;
	int index = ctemp.ReverseFind('\\');
	CString strFilePath = ctemp.Left(index+1);
	CString strFileName;
	strFileName.Format(_T("%s_%s.log"), strFile, COleDateTime::GetCurrentTime().Format(_T("%Y%m%d")));
	strFilePath += _T("error\\");
	strFilePath += strFileName;
	if (cfErrorLog == NULL){
		return FALSE;
	}
	BOOL bOpenFile=FALSE;//是否需要重新打开文件
	if(cfErrorLog.m_pStream==NULL){
		bOpenFile=TRUE;
	}else{
		if(cfErrorLog.GetFilePath()!=strFilePath){
			bOpenFile=TRUE;
			cfErrorLog.Close();
		}
	}
	if(bOpenFile){
		return cfErrorLog.Open(strFilePath, CFile::modeCreate|CFile::modeNoTruncate|CFile::modeWrite|CFile::shareDenyNone);
	}else{
		return TRUE;
	}
}

void CYAServerDlg::OnBnExit()
{
	stop_tcp_server();
	clear_all_list();
	GetConnPool().CloseAllConn();
	CDialogEx::OnCancel();
}

void CYAServerDlg::OnBnSyncTime()
{
	send_sync_reader();
}

CYAServerDlg::~CYAServerDlg()
{
	ws_close();
}

void CYAServerDlg::OnConnected()
{
	is_websocket_ok = true;
	//Sleep(50); // need delay

}

void CYAServerDlg::OnClosed( client::close_reason const& reason )
{
	int i = -1;
	if(reason == client::close_reason_drop){
		i = (int) reason;
	}else{
		i = (int) reason;
	}
}

void CYAServerDlg::OnFailed()
{
	is_websocket_login = false;
	is_websocket_ok = false;
}

void CYAServerDlg::ws_open()
{
	_io->connect(m_ws_url);
	CString strlog;
	strlog.Format(_T("%s: %s"), _T(LOG_CONNECT_WEB_SERVER), CFunctions::c2wc(m_ws_url.c_str()));
	show_log(strlog);
}

void CYAServerDlg::OnPushMessage()
{
	string aa = "";
}

std::string CYAServerDlg::get_json_down_and_up( Card* card )
{
	Json::Value root;
	Json::Value val_map;
	Json::Value val_maps;
	Json::Value val_card;
	Json::Value val_cards;

	char _time[STR_LEN_TIME];
	struct tm local_time;

	val_card[JSON_KEY_CARD_ID] = card->card_id;
	val_card[JSON_KEY_CARD_TYPE_ID] = card->card_type;
	val_card[JSON_KEY_CARD_NUM] = card->id;

	localtime_s(&local_time, &card->down_time);
	strftime(_time, STR_LEN_TIME, "%Y-%m-%d %H:%M:%S", &local_time);
	val_card[JSON_KEY_DOWN_TIME] = _time;

	val_card[JSON_KEY_WORK_TIME] = CFunctions::getworktimebysec((int)difftime(time(NULL), card->down_time));
	localtime_s(&local_time, &card->enter_area_time);
	strftime(_time, STR_LEN_TIME, "%Y-%m-%d %H:%M:%S", &local_time);
	val_card[JSON_KEY_ENTER_AREA_TIME] = _time;

	val_card[JSON_KEY_AREA_ID] = card->area_id;
	val_card[JSON_KEY_STATE] = card->state;

	localtime_s(&local_time, &card->rec_time);
	strftime(_time, 30, "%Y-%m-%d %H:%M:%S", &local_time);
	val_card[JSON_KEY_REC_TIME] = _time;

	val_card[JSON_KEY_CORDINATE_X] = card->x;
	val_card[JSON_KEY_CORDINATE_Y] = card->y;
	val_card[JSON_KEY_CORDINATE_Z] =  0; // card->z;
	val_cards.append(val_card);	

	val_map[JSON_KEY_MAP_ID] = card->map_id;
	val_map[JSON_KEY_POS_CARD] = val_cards;
	val_maps.append(val_map);

	root[JSON_ROOT_KEY_CMD] = (DT_DOWN == card->pos_state)? JSON_CMD_VALUE_DOWN_MINE : JSON_CMD_VALUE_UP_MINE;
	root[JSON_ROOT_KEY_DATA] = val_maps;
	string ss = root.toStyledString();
	return root.toFastString();
}

void CYAServerDlg::store_data_card( Card* card, int tag )
{
	//return;
	char sql[LENGTH_SQL] = {0};
	char _time[STR_LEN_TIME], _time_ex[STR_LEN_TIME];
	struct tm local_time, local_time_ex;
	localtime_s(&local_time, &card->deal_time);
	strftime(_time, 30, "%Y-%m-%d %H:%M:%S", &local_time);

	bool b_exec = false;

	switch(tag){
	case TEST_LOCATE_COMPARE:
		{
			b_exec = true;
			sprintf_s(sql, LENGTH_SQL, 
				"INSERT INTO test_locate_compare(x, y, xx, yy, x1, x2, x3, x4, y1, y2, y3, y4, rec_time)\
				VALUES(%.5f, %.5f, %.5f, %.5f, %.5f, %.5f, %.5f, %.5f, %.5f, %.5f, %.5f, %.5f, '%s');",
				card->x, card->y, card->xx, card->yy, card->x1, card->x2, card->x3, card->x4, 
				card->y1, card->y2, card->y3, card->y4, _time);
			break;
		}
	case TEST_LOCATE_DATA:
		{
			b_exec = true;
			sprintf_s(sql, LENGTH_SQL, 
				"INSERT INTO test_locatedata(card_id, reader_id, antenna_id, \
				reader_stamp, card_stamp, locatetime, distance, stamp_type, power_state,\
				accelerate, rec_time, card_x, card_y) \
				VALUES(%s, %d, %d, %d, %d, %lld, %f, %d, %d, %d, '%s', %.4f, %.4f);",
				card->card_id.c_str(), card->reader_id, card->antenna_id, card->p_reader->tick_count, card->time_stamp,
				card->flying_time, card->distance, card->ranging_type, card->power_state, card->accelerate_state, 
				_time, card->x, card->y);
			break;
		}
	case HIS_LOCATION:
		{
			if(card->map_id != 0 && card->area_id != 0){
				b_exec = true;
				sprintf_s(sql, LENGTH_SQL, 
					"INSERT INTO his_location(card_id, cur_time, x, y, z, map_id, area_id, state) \
					VALUES(%s, '%s', %4.f, %4.f, %4.f, %d, %d, %d);",  
					card->card_id.c_str(), _time, card->x, card->y, card->z, card->map_id, card->area_id, card->state);
			}
			break;
		}
	case HIS_RAW_DATA:
		{
			b_exec = true;
			sprintf_s(sql, LENGTH_SQL,
				"INSERT INTO his_raw_data(card_id, reader_id, antenna_id, reader_stamp, card_stamp, \
				fly_time, distance, ranging_type, power_state, accelerate, his_time, rec_time ) \
				VALUES(%s, %d, %d, %d, %d, %lld, %4.f, %d, %d, %d, '%s', '%s');",
				card->card_id.c_str(), card->reader_id, card->antenna_id, card->reader_tickcount, card->time_stamp,
				card->flying_time, card->distance, card->ranging_type, card->power_state, card->accelerate_state,
				card->str_his_time.c_str(), card->str_rec_time.c_str());
			break;
		}
	case HIS_AREA_LOCATION_ENTER:
		{
			if(card->map_id != 0 && card->area_id != 0){
				b_exec = true;
				sprintf_s(sql, LENGTH_SQL,
					"INSERT INTO his_location_area(card_id, area_id, map_id, enter_time) VALUES(%s, %d, %d, '%s')",
					card->card_id.c_str() , card->area_id, card->map_id, _time);
			}
			break;
		}
	case HIS_AREA_LOCATION_LEAVE:
		{
			if(card->map_id != 0 && card->area_id != 0){
				b_exec = true;
				localtime_s(&local_time_ex, &card->enter_area_time);
				strftime(_time_ex, 30, "%Y-%m-%d %H:%M:%S", &local_time_ex);
				sprintf_s(sql, LENGTH_SQL,
					"UPDATE his_location_area SET leave_time = '%s' WHERE card_id = %s AND area_id=%d AND enter_time = '%s';",
					_time, card->card_id.c_str(), card->area_id, _time_ex);
			}
			break;
		}
	case RPT_ATTEND_DOWN:
		{
			if(card->map_id != 0 && card->area_id != 0){
				b_exec = true;
				sprintf_s(sql, LENGTH_SQL,
					"INSERT INTO rpt_attendance(card_id, start_time, att_date) VALUES(%s, '%s', '%s')",
					card->card_id.c_str(), _time, _time);
			}
			break;
		}
	case RPT_ATTEND_UP:
		{
			if(card->map_id != 0 && card->area_id != 0){
				b_exec = true;
				localtime_s(&local_time_ex, &card->down_time);
				strftime(_time_ex, 30, "%Y-%m-%d %H:%M:%S", &local_time_ex);
				sprintf_s(sql, LENGTH_SQL,
					"UPDATE rpt_attendance SET end_time = '%s' WHERE card_id = %s AND start_time = '%s';",
					_time, card->card_id.c_str(), _time_ex);
			}
			break;
		}
	case ALARM_CARD_LOW_POWER_START:
		{
			b_exec = true;
			int alarm_type_id = ATID_POWER;
			sprintf_s(sql, LENGTH_SQL,
				"INSERT INTO his_alarm_card(card_id, alarm_type_id, card_type_id, start_time) \
				VALUES(%s, %d, %d, '%s')",
				card->card_id.c_str(), alarm_type_id, card->card_type, _time);
			break;
		}
	case ALARM_CARD_LOW_POWER_END:
		{
			b_exec = true;
			localtime_s(&local_time_ex, &card->low_power_time);
			strftime(_time_ex, 30, "%Y-%m-%d %H:%M:%S", &local_time_ex);

			int alarm_type_id = ATID_POWER;
			sprintf_s(sql, LENGTH_SQL,
				"UPDATE his_alarm_card SET end_time = '%s' WHERE card_id=%s AND alarm_type_id=%d AND start_time = '%s';",
				_time, card->card_id.c_str(), alarm_type_id, _time_ex);
			break;
		}
		//case ALARM_CARD_OVER_TIME_AREA_START:
		//	{
		//		int alarm_type_id = ATID_AREA_OVER_TIME_PERSON;
		//		if(CT_VEHICLE == card->card_type){
		//			alarm_type_id = ATID_AREA_OVER_TIME_VEHICLE;
		//		}
		//		sprintf_s(sql, LENGTH_SQL,
		//			"INSERT INTO his_alarm_card(card_id, alarm_type_id, card_type_id, start_time) \
		//			VALUES(%s, %d, %d, '%s')",
		//			card->card_id.c_str(), alarm_type_id, card->card_type, _time);
		//		break;
		//	}
		//case ALARM_CARD_OVER_TIME_AREA_END:
		//	{
		//		localtime_s(&local_time_ex, &card->time_area_over_time);
		//		strftime(_time_ex, 30, "%Y-%m-%d %H:%M:%S", &local_time_ex);

		//		int alarm_type_id = ATID_AREA_OVER_TIME_PERSON;
		//		if(CT_VEHICLE == card->card_type){
		//			alarm_type_id = ATID_AREA_OVER_TIME_VEHICLE;
		//		}

		//		sprintf_s(sql, LENGTH_SQL,
		//			"UPDATE his_alarm_card SET end_time = '%s' \
		//			WHERE card_id=%s AND alarm_type_id=%d AND start_time = '%s';",
		//			_time, card->card_id.c_str(), alarm_type_id, _time_ex);
		//		break;
		//	}
		//case ALARM_CARD_OVER_TIME_START:
		//	{
		//		int alarm_type_id = ATID_OVER_TIME_PERSON;
		//		if(CT_VEHICLE == card->card_type){
		//			alarm_type_id = ATID_OVER_TIME_VEHICLE;
		//		}
		//		sprintf_s(sql, LENGTH_SQL,
		//			"INSERT INTO his_alarm_card(card_id, alarm_type_id, card_type_id, start_time) \
		//			VALUES(%s, %d, %d, '%s')",
		//			card->card_id.c_str(), alarm_type_id, card->card_type, _time);
		//		break;
		//	}
		//case ALARM_CARD_OVER_TIME_END:
		//	{
		//		localtime_s(&local_time_ex, &card->time_over_time);
		//		strftime(_time_ex, 30, "%Y-%m-%d %H:%M:%S", &local_time_ex);

		//		int alarm_type_id = ATID_OVER_TIME_PERSON;
		//		if(CT_VEHICLE == card->card_type){
		//			alarm_type_id = ATID_OVER_TIME_VEHICLE;
		//		}
		//		sprintf_s(sql, LENGTH_SQL,
		//			"UPDATE his_alarm_card SET end_time = '%s' \
		//			WHERE card_id=%s AND alarm_type_id=%d AND start_time = '%s';",
		//			_time, card->card_id.c_str(), alarm_type_id, _time_ex);
		//		break;
		//	}
	default:
		return;
	}
	try
	{
		if(b_exec){
			execute_sql(sql);
		}
	}
	catch (...)
	{
		CString str;
		str.Format(_T("%s\n"), CFunctions::c2wc(sql));
		writeErrorLog(_T("SQL_S"), str);
	}
}

std::string CYAServerDlg::get_json_counting()
{
	Json::Value root;
	Json::Value data;
	Json::Value mapcounts;
	int total_count = 0,total_count_vehicle = 0,total_count_person = 0;
	int map_count_total, map_count_vehicle, map_count_person;
	int area_count_total, area_count_vehicle, area_count_person;
	MapInfoMap::iterator it_map = mp_map_list.begin();
	for(; it_map != mp_map_list.end(); ++it_map){
		Json::Value mapcount;
		Json::Value areacounts;
		// area
		map_count_total = map_count_vehicle = map_count_person = 0;
		AreaMap::iterator it_area = it_map->second->map_area_list.begin();
		for(; it_area != it_map->second->map_area_list.end(); ++it_area){
			area_count_total = area_count_vehicle = area_count_person = 0;
			Json::Value areacount;
			// person
			CardMap::iterator it_card = it_area->second->area_card_list_person.begin();
			for(; it_card != it_area->second->area_card_list_person.end(); ++ it_card){
				if(DT_DOWN == it_card->second->pos_state){
					area_count_person++;
					area_count_total++;
				} else {
					continue;
				}
			}
			// vehicle
			it_card = it_area->second->area_card_list_vehicle.begin();
			for(; it_card != it_area->second->area_card_list_vehicle.end(); ++ it_card){
				if(DT_DOWN == it_card->second->pos_state){
					area_count_vehicle++;
					area_count_total++;
				} else {
					continue;
				}
			}
			//if(area_count_total > 0){
			areacount[JSON_KEY_COUNTING_AREA_COUNT_PERSON] = area_count_person;
			areacount[JSON_KEY_COUNTING_AREA_COUNT_VEHICLE] = area_count_vehicle;
			areacount[JSON_KEY_COUNTING_AREA_COUNT] = area_count_total;
			areacount[JSON_KEY_COUNTING_AREA_ID] = it_area->second->area_id;
			map_count_total += area_count_total;
			map_count_person += area_count_person;
			map_count_vehicle += area_count_vehicle;
			areacounts.append(areacount);
			//}
		}
		//if(map_count_total > 0){
		mapcount[JSON_KEY_COUNTING_MAP_ID] = it_map->second->map_id;
		mapcount[JSON_KEY_COUNTING_MAP_COUNT_PERSON] = map_count_person;
		mapcount[JSON_KEY_COUNTING_MAP_COUNT_VEHICLE] = map_count_vehicle;
		mapcount[JSON_KEY_COUNTING_MAP_COUNT_TOTAL] = map_count_total;
		mapcount[JSON_KEY_COUNTING_AREA_COUNT] = areacounts;
		total_count += map_count_total;
		total_count_person += map_count_person;
		total_count_vehicle += map_count_vehicle;
		mapcounts.append(mapcount);
		//}
	}
	// dept
	Json::Value deptcounts;
	Json::Value deptcount;
	int dept_person_count, dept_vehicle_count, total_dept_count = 0;
	DeptMap::iterator it_dept = mp_dept_list.begin();
	for(; it_dept != mp_dept_list.end(); ++it_dept){
		deptcount[JSON_KEY_COUNTING_DEPT_ID] = it_dept->second->dept_id;
		//deptcount[JSON_KEY_COUNTING_DEPT_NAME] = it_dept->second->dept_name;
		dept_person_count = it_dept->second->dept_card_list_person.size();
		dept_vehicle_count = it_dept->second->dept_card_list_vehicle.size();
		deptcount[JSON_KEY_COUNTING_DEPT_COUNT_TOTAL] = dept_person_count + dept_vehicle_count;
		deptcount[JSON_KEY_COUNTING_DEPT_COUNT_PERSON] = dept_person_count;
		deptcount[JSON_KEY_COUNTING_DEPT_COUNT_VEHICLE] = dept_vehicle_count;
		//if(dept_vehicle_count + dept_person_count > 0){
		//	total_dept_count += dept_vehicle_count + dept_person_count;
		deptcounts.append(deptcount);
		//}
	}
	//if(total_dept_count>0){
	data[JSON_KEY_COUNTING_DEPT_COUNT] = deptcounts;
	//}
	data[JSON_KEY_COUNTING_MAP_COUNT] = mapcounts;
	data[JSON_KEY_COUNTING_COUNT_TOTAL] = total_count;
	data[JSON_KEY_COUNTING_COUNT_VEHICLE] = total_count_vehicle;
	data[JSON_KEY_COUNTING_COUNT_PERSON] = total_count_person;
	root[JSON_ROOT_KEY_DATA] = data;
	root[JSON_ROOT_KEY_CMD] = JSON_CMD_VALUE_COUNTING;

	string ss = root.toStyledString();
	return root.toFastString();
}

void CYAServerDlg::OnTimer( UINT nIDEvent )
{
	// 需要优化，如果数据没有变化，则不重复发送数据，数据变化后再发送
	switch ( nIDEvent)
	{
	case TMR_SEND_COUNTING:
		{
			send_json_data(JSON_CMD_VALUE_PUSH, get_json_counting());
			break;	
		}
	case TMR_SEND_ALARM:
		{
			send_json_data(JSON_CMD_VALUE_PUSH, get_json_alarm());
			break;
		}
	case TMR_SEND_DEVICE_STATE:
		{
			deal_readers();
			send_json_data(JSON_CMD_VALUE_PUSH, get_json_device_state());
			break;
		}
	case TMR_SEND_POSTION:
		{
			package_data();
			break;
		}
	case TMR_SYNC_READER_TIME:
		{
			send_sync_reader();
			break;
		}
	case TMR_CLEAR_CALL_TIMER:
		{
			clear_call_info();
			break;
		}
	case TMR_SEND_CALL:
		{
			send_call_info();
			break;
		}
	default:
		break;
	}
}

void CYAServerDlg::load_param_from_ini()
{
	IniFile ini;
	string strvalue;
	int nTemp = 0;
	show_log(_T(LOG_LOAD_CONFIG), FALSE);
	if(ini.open(FILEPATH_SERVER_CONFIG)){
		strvalue = ini.read(CONF_SECT_SERVER_SETTING, CONF_SERVER_WS_URL);
		m_ws_url = strvalue;

		m_db_setting.host = ini.read(CONF_SECT_DB, CONF_DB_KEY_HOST);
		m_db_setting.user = ini.read(CONF_SECT_DB, CONF_DB_KEY_USER);
		m_db_setting.password = ini.read(CONF_SECT_DB, CONF_DB_KEY_PWD);
		m_db_setting.dbname = ini.read(CONF_SECT_DB, CONF_DB_KEY_DBNAME);
		m_db_setting.encoding = ini.read(CONF_SECT_DB, CONF_DB_KEY_ENCODING);
		m_db_setting.port = atoi(ini.read(CONF_SECT_DB, CONF_DB_KEY_PORT).c_str());

		show_log(_T(LOG_LOAD_CONFIG_SUCCESS), FALSE);
	}else{
		show_log(_T(LOG_LOAD_CONFIG_FAIL));
	}
}

int CYAServerDlg::init_dept()
{
	CMysqlConn* pConn = NULL;
	CDBConnGuard pDbGuard(pConn);
	MYSQL_ROW pRow;
	MYSQL_RES *pRes = NULL;
	int err = 0;
	pRes = pConn->Execute("select dept_id, name from dat_dept order by rank;", err);
	Dept* dept = NULL;
	int nRow = 0;
	while(pRow = mysql_fetch_row(pRes))	{
		DeptMap::iterator it = mp_dept_list.find(atoi(pRow[0]));		
		if(it != mp_dept_list.end()){
			dept = it->second;
		}else{
			dept = new Dept(atoi(pRow[0]), pRow[1]);
			mp_dept_list.insert(make_pair(dept->dept_id, dept));
			nRow++;
		}
	}
	mysql_free_result(pRes);
	CString strlog;
	strlog.Format(_T("%s%d%s"), _T(LOG_INIT_DEPT), nRow, _T(LOG_RECORD_COUNT));
	show_log(strlog);
	return 0;
}

int CYAServerDlg::init_setting()
{
	CMysqlConn* pConn = NULL;
	CDBConnGuard pDbGuard(pConn);
	MYSQL_ROW pRow;
	MYSQL_RES *pRes = NULL;
	int err = 0;
	pRes = pConn->Execute("select setting_id, name, type, value from dat_setting;", err);
	string name, val, type;
	while(pRow = mysql_fetch_row(pRes))	{
		name = pRow[1], type = pRow[2],	val = pRow[3];
		if("over_count_person" == name){
			sls_setting.over_count_person = atoi(val.c_str());
		}else if("over_count_vehicle" == name){
			sls_setting.over_count_vehicle = atoi(val.c_str());
		}else if("over_time_person" == name){
			sls_setting.over_time_person = atoi(val.c_str());
		}else if("over_time_vehicle" == name){
			sls_setting.over_time_vehicle = atoi(val.c_str());
		}else if("over_speed" == name){
			sls_setting.over_speed = atof(val.c_str());
		}
	}
	mysql_free_result(pRes);
	show_log(_T(LOG_INIT_SETTING));
	return 0;
}

void CYAServerDlg::deal_alarm_card(Card* card, CardMap* dest_card_list, bool is_alarm, ALARM_FLAG tag)
{
	CardMap::iterator it_card = dest_card_list->find(card->card_id);
	if(it_card != dest_card_list->end()){
		if(!is_alarm){ // 取消报警
			dest_card_list->erase(it_card);
		}
	}else {
		if(is_alarm){
			dest_card_list->insert(make_pair(card->card_id, card));
		} 
	}

	switch (tag) // savetodb
	{
	case AF_CARD_AREA_FORBIDDEN:
		{
			card->time_area_forbidden = is_alarm ? time(NULL) : 0;
			card->status_area_forbidden = is_alarm ? 1 : 0;
			break;
		}
	case AF_CARD_AREA_OVER_TIME:
		{
			card->time_area_over_time = is_alarm ? time(NULL) : 0;
			card->status_area_over_time = is_alarm ? 1 : 0;
			break;
		}
	case AF_AREA_OVER_TIME:
		{
			card->time_over_time = is_alarm ? time(NULL) : 0;
			card->status_over_time = is_alarm ? 1 : 0;
			break;
		}
	case AF_CARD_OVER_SPEED:
		{
			card->time_over_speed = is_alarm ? time(NULL) : 0;
			card->status_over_speed = is_alarm ? 1 : 0;
			break;
		}
	default:
		break;
	}
}

void CYAServerDlg::deal_alarm_area( Area* area, AreaMap* dest_area_list, bool is_alarm, ALARM_FLAG tag )
{
	AreaMap::iterator it_area = dest_area_list->find(area->area_id);
	if(it_area != dest_area_list->end()){
		if(!is_alarm){
			//savetodb
			dest_area_list->erase(it_area);
		}
	}else{
		if(is_alarm){
			// savetodb
			dest_area_list->insert(make_pair(area->area_id, area));
		}
	}
}

int CYAServerDlg::init_alarm_type()
{
	CMysqlConn* pConn = NULL;
	CDBConnGuard pDbGuard(pConn);
	MYSQL_ROW pRow;
	MYSQL_RES *pRes = NULL;
	int err = 0;
	pRes = pConn->Execute("select alarm_type_id, name from dat_alarm_type;", err);
	while(pRow = mysql_fetch_row(pRes))	{
		AlarmTypeMap::iterator it = mp_alarm_type_list.find(atoi(pRow[0]));		
		if(it != mp_alarm_type_list.end()){
			it->second = pRow[1];
		}else{
			mp_alarm_type_list.insert(make_pair(atoi(pRow[0]), pRow[1]));
		}
	}
	mysql_free_result(pRes);
	show_log(_T(LOG_INIT_ALARM_TYPE));
	return 0;
}

void CYAServerDlg::AddItem( CString strvalue, int readerid, BOOL is_closed /*= false*/ )
{
	CString strRow;
	int nRow = 0;
	bool bFind = false;
	for(int i = 0; i < m_listctrl_reader.GetItemCount(); i++){
		if(strvalue == m_listctrl_reader.GetItemText(i, 1)){
			nRow = i;
			bFind = true;
			break;
		}
	}
	if(!bFind){
		nRow = m_listctrl_reader.GetItemCount();
		//strRow.Format(_T("%d"), nRow + 1);
		nRow = m_listctrl_reader.InsertItem(nRow, CFunctions::formatInt(readerid));
	}
	m_listctrl_reader.SetItemText(nRow, 1, strvalue);
	m_listctrl_reader.SetItemText(nRow, 2, is_closed ? _T("中断"): _T("已连接"));
}

void CYAServerDlg::show_log( LPCTSTR szlog, BOOL bSave )
{
	CString sMsg, sLog;
	CString sTime=COleDateTime::GetCurrentTime().Format(_T(LOG_TIME_FORMAT));
	sMsg.Format(_T("%s %s\n"), sTime, szlog);
	try{
		::LogMsg(sMsg);
	}
	catch(...){
	}
	if(bSave && theApp.log_status){
		writeErrorLog(_T("LOG_S"), sMsg);
	}
}

void CYAServerDlg::database_connect()
{
	show_log(_T(LOG_CONNECT_DB), FALSE);
	GetConnPool().Init(m_db_setting.encoding.c_str(), m_db_setting.host.c_str(), m_db_setting.user.c_str(), 
		m_db_setting.password.c_str(), m_db_setting.dbname.c_str(), m_db_setting.port, NULL, 0);
	int nConn = GetConnPool().InitAllConn();
	if(nConn > 0){
		show_log(_T(LOG_CONNECT_DB_SUCCESS));
	}else{
		show_log(_T(LOG_CONNECT_DB_FAIL));
	}
}

void CYAServerDlg::stop_timer()
{
	KillTimer(TMR_SEND_COUNTING);
	KillTimer(TMR_SEND_ALARM);
	KillTimer(TMR_SEND_DEVICE_STATE);
	KillTimer(TMR_SEND_POSTION);
}

void CYAServerDlg::OnMenuDb()
{
	CDbSettingDlg dlg;
	dlg.DoModal();
}

void CYAServerDlg::OnCallMessage( string const& name, message::ptr const& data, bool isAck,message::list &ack_resp )
{
	if(data->get_flag() == message::flag_object){
		string cmd = data->get_map()[JSON_ROOT_KEY_CMD]->get_string();
		if(JSON_CMD_VALUE_META_DATA_CHANGED == cmd){
			map<string,message::ptr> data_map = data->get_map()[JSON_ROOT_KEY_DATA]->get_map();
			string name = data_map[JSON_KEY_NAME]->get_string();
			string op_type = data_map[JSON_KEY_OP_TYPE]->get_string();
			EDIT_TYPE_ID edit_type_id = (JSON_KEY_OP_TYPE_INSERT == op_type)? ET_INSERT: ((JSON_KEY_OP_TYPE_UPDATE == op_type)? ET_UPDATE: ET_DELETE);
			if(JSON_KEY_NAME_VEHICLE == name){
				string id = data_map[JSON_KEY_ID]->get_string();
				deal_call_edit_vehicle(id, edit_type_id);
			}else if(JSON_KEY_NAME_STAFF == name){
				string id = data_map[JSON_KEY_ID]->get_string();
				deal_call_edit_staff(id, edit_type_id);
			}else if(JSON_KEY_NAME_READER == name){
				int id = atoi(data_map[JSON_KEY_ID]->get_string().c_str());
				deal_call_edit_reader(id, edit_type_id);
			}else if(JSON_KEY_NAME_CARD == name){
				string id = data_map[JSON_KEY_ID]->get_string();
				deal_call_edit_card(id, edit_type_id);
			}else if(JSON_KEY_NAME_AREA == name){
				int id = atoi(data_map[JSON_KEY_ID]->get_string().c_str());
				deal_call_edit_area(id, edit_type_id);
			}else if(JSON_KEY_NAME_MAP == name){
				int id = atoi(data_map[JSON_KEY_ID]->get_string().c_str());
				deal_call_edit_map(id, edit_type_id);
			}else if(JSON_KEY_NAME_PATH == name){
				//int id = data_map[JSON_KEY_ID]->get_int();
				//deal_call_edit_path(id, edit_type_id);
			}
		}
		//cmd = data->get_map()[JSON_ROOT_KEY_DATA]->get_map()["name"]->get_string();
		//string json_data = data->get_map()[JSON_ROOT_KEY_DATA]->get_string();

		//if(JSON_CMD_VALUE_CALL_CARD == cmd){		
		//	parse_json_data_call_card(json_data.c_str());
		//} else if(JSON_CMD_VALUE_SET_LIMIT_VALUE == cmd){
		//	parse_json_data_set_limit_value(json_data.c_str());
		//} else if(JSON_CMD_VALUE_REQUEST_ALL_POSTION == cmd){
		//	send_json_data(JSON_CMD_VALUE_REQUEST_ALL_POSTION, get_json_postion_all());
		//} else if(JSON_CMD_VALUE_EDIT_VEHICLE == cmd){
		//	parse_json_data_edit_vehicle(json_data.c_str());
		//} else if(JSON_CMD_VALUE_EDIT_STAFFER == cmd){
		//	parse_json_data_edit_staffer(json_data.c_str());
		//} else if(JSON_CMD_VALUE_EDIT_STATION == cmd){
		//	parse_json_data_edit_reader(json_data.c_str());
		//} else if(JSON_CMD_VALUE_EDIT_AREA == cmd){
		//	parse_json_data_edit_area(json_data.c_str());
		//} else if(JSON_CMD_VALUE_EDIT_CARD == cmd){
		//	parse_json_data_edit_card(json_data.c_str());
		//} else if(JSON_CMD_VALUE_EDIT_PATH == cmd){
		//	//parse_json_data_edit_path(json_data.c_str());
		//} else if(JSON_CMD_VALUE_EDIT_MAP == cmd){
		//	parse_json_data_edit_map(json_data.c_str());
		//} else if(JSON_CMD_VALUE_DEAL_HELP == cmd){
		//	parse_json_data_deal_help(json_data.c_str());
		//} else if(JSON_CMD_VALUE_CLEAR_CARD == cmd) {
		//		parse_json_data_clear_card(json_data.c_str());
		//}
	}
}

void CYAServerDlg::parse_json_data_set_limit_value( const char* sz )
{
	//USES_CONVERSION;
	//CUTF82C strJson(szJson);
	Json::Value root;
	Json::Reader reader;
	CString strlog;
	if (!reader.parse(sz,root)){
		strlog.Format(_T("%s%s"), _T(LOG_SET_LIMIT_VALUE), _T(LOG_FAIL));
		show_log(strlog);
		return ;
	}
	sls_setting.over_count_person = root[JSON_KEY_ALARM_OVER_COUNT_PERSON].asInt();
	sls_setting.over_count_vehicle = root[JSON_KEY_ALARM_OVER_COUNT_VEHICLE].asInt();
	sls_setting.over_time_person = root[JSON_KEY_ALARM_OVER_TIME_PERSON].asInt();
	sls_setting.over_time_vehicle = root[JSON_KEY_ALARM_OVER_TIME_VEHICLE].asInt();
	sls_setting.over_speed = root[JSON_KEY_ALARM_OVER_SPEED_VEHICLE].asDouble();

	strlog.Format(_T("%s%s"), _T(LOG_SET_LIMIT_VALUE), _T(LOG_SUCCESS));
	show_log(strlog);
}

void CYAServerDlg::parse_json_data_call_card( const char* sz )
{
	Json::Value root;
	Json::Reader reader;
	CString strlog;
	if (!reader.parse(sz,root)){
		strlog.Format(_T("%s%s"), _T(LOG_CALL_CARD), _T(LOG_FAIL));
		show_log(strlog);
		return ;
	}
	Json::Value data;
	Json::Value stations;
	Json::Value cards;
	int time_out, reader_count, card_count, call_type;
	string user_name, call_time;
	string cardid, readerid;
	data = root[JSON_ROOT_KEY_DATA];
	time_out = data[JSON_KEY_CALL_CARD_CALL_TIME_OUT].asInt();
	user_name = data[JSON_KEY_CALL_CARD_USER_NAME].asString();
	call_time = data[JSON_KEY_CALL_CARD_CALL_TIME].asString();
	call_type = data[JSON_KEY_CALL_CARD_CALL_TYPE].asInt();
	stations = data[JSON_KEY_CALL_CARD_STATIONS];
	cards = data[JSON_KEY_CALL_CARD_CARDS];
	if (stations.isNull() || !stations.isArray() || cards.isNull() || !cards.isArray()){
		strlog.Format(_T("%s%s"), _T(LOG_CALL_CARD), _T(LOG_FAIL));
		show_log(strlog);
		return ;
	}
	int reader_id, npos;
	//SocketMap::iterator it_sock;
	//BYTE buf[LENGTH_SEND_BUF];
	_call_info_reader* call_reader;
	_call_info_card* call_card;
	for(unsigned int i = 0; i < stations.size(); i++){
		reader_id = stations[i][JSON_KEY_CALL_CARD_STATION_ID].asInt();

		CallInfoReaderMap::iterator it_call_reader = mp_call_info.find(reader_id);
		if(it_call_reader != mp_call_info.end()){
			call_reader = it_call_reader->second;
			if(call_reader->call_type > call_type){
				call_reader->call_type = call_type;
			}
		}else{
			call_reader = new _call_info_reader;
			call_reader->call_type = call_type;
			mp_call_info.insert(make_pair(reader_id, call_reader));
		}
		card_count = cards.size();
		unsigned int j = 0;
		if(/*card_count == 1 &&*/ 0 == cards[j][JSON_KEY_CALL_CARD_CARD_ID].asInt()){ // 卡号为0,全员呼叫
			call_reader->cards_count = 0;
			call_reader->is_call_all = true;
		}else{
			call_reader->cards_count = card_count;
			call_reader->is_call_all = false;
			for(j = 0; j < cards.size(); j++){ // 解析卡号
				int card_id =  cards[j][JSON_KEY_CALL_CARD_CARD_ID].asInt();
				BYTE card_type = cards[j][JSON_KEY_CALL_CARD_CARD_TYPE_ID].asInt();
				string str_card_id = CFunctions::getstrwithzero(card_type, 3) + CFunctions::getstrwithzero(card_id, 10);
				CallInfoCardMap::iterator it_call_card = call_reader->mpCard.find(str_card_id);
				if(it_call_card != call_reader->mpCard.end()){ // 已在呼叫列表
					call_card = it_call_card->second;
					if(call_card->call_type < call_type){ // 原呼叫优先级低
						call_card->card_type = card_type;
						call_card->call_type = call_type;
						call_card->start_time = time(NULL);
						call_card->time_out = time_out;
					}else {
						call_card->start_time = time(NULL);
						call_card->time_out = time_out;
					}
				}else{ // 未在呼叫列表
					call_card = new _call_info_card;
					call_card->card_id = card_id;
					call_card->card_type = card_type;
					call_card->start_time = time(NULL);
					call_card->time_out = time_out;
					call_card->call_type = call_type;
					call_reader->mpCard.insert(make_pair(str_card_id, call_card));
				}

				//int card_id =  cards[j][JSON_KEY_CALL_CARD_CARD_ID].asInt();
				//memcpy(&buf[npos], &card_type, sizeof(BYTE));
				//npos += sizeof(BYTE);
				//CFunctions::memcpyDWord(buf, card_id, npos);
				//npos += sizeof(DWORD);
			}
		}

		//	it_sock = mp_socket_list.find(reader_id);
		//	if(it_sock != mp_socket_list.end()){ // 发送呼叫信息
		//		memset(buf, 0, LENGTH_SEND_BUF);
		//		npos = 0;

		//		int j = 0;
		//		if(card_count == 1){
		//			if(0 == cards[j][JSON_KEY_CALL_CARD_CARD_ID].asInt()){
		//				card_count = 0;
		//				memcpy(&buf[npos], &card_count, sizeof(BYTE));
		//				npos += sizeof(BYTE);
		//				CFunctions::memcpyWord(buf, time_out, npos);
		//				npos += sizeof(WORD);					
		//			}
		//		}else{
		//			memcpy(&buf[npos], &card_count, sizeof(BYTE));
		//			npos += sizeof(BYTE);
		//			CFunctions::memcpyWord(buf, time_out, npos);
		//			npos += sizeof(WORD);
		//			for(j = 0; j < cards.size(); j++){
		//				BYTE card_type = cards[j][JSON_KEY_CALL_CARD_CARD_TYPE_ID].asInt();
		//				int card_id =  cards[j][JSON_KEY_CALL_CARD_CARD_ID].asInt();
		//				memcpy(&buf[npos], &card_type, sizeof(BYTE));
		//				npos += sizeof(BYTE);
		//				CFunctions::memcpyDWord(buf, card_id, npos);
		//				npos += sizeof(DWORD);
		//			}
		//		}
		//		it_sock->second->SendData(CHAR_CALL, npos, buf);
		//	}
	}
	strlog.Format(_T("%s%s"), _T(LOG_CALL_CARD), _T(LOG_SUCCESS));
	show_log(strlog);
}

void CYAServerDlg::parse_json_data_clear_card( const char* sz )
{
	Json::Value root;
	Json::Reader reader;
	CString strlog;
	if (!reader.parse(sz,root)){
		strlog.Format(_T("%s%s"), _T(LOG_CLEAR_CARD), _T(LOG_FAIL));
		show_log(strlog);
		return ; 
	}
	if(root.isNull() || !root.isArray()){
		return; 
	}
	int card_type_id, edit_type_id;
	string cardid = "";
	for(unsigned int i = 0; i < root.size(); i++){
		cardid = root[i][JSON_KEY_EDIT_CARD_ID].asString();
		edit_type_id = root[i][JSON_KEY_EDIT_EDIT_TYPE_ID].asInt();
		CardMap::iterator it_card = mp_card_list_all.find(cardid);
		if(it_card != mp_card_list_all.end()){
			if(STATUS_ERROR == it_card->second->status_lost){
				// 升井
				it_card->second->up_time = time(NULL);
				it_card->second->pos_state = DT_UP;
				card_enter_mine(it_card->second);
				remove_card(cardid); // reset_card_status();
			}
		}		
	}
	strlog.Format(_T("%s%s"), _T(LOG_CLEAR_CARD), _T(LOG_SUCCESS));
	show_log(strlog);	
}

void CYAServerDlg::parse_json_data_deal_help( const char* sz )
{
	Json::Value root;
	Json::Reader reader;
	CString strlog;
	if (!reader.parse(sz,root)){
		strlog.Format(_T("%s%s"), _T(LOG_DEAL_HELP), _T(LOG_FAIL));
		show_log(strlog);
		return ; 
	}
	int card_type_id, edit_type_id;
	string cardid = root[JSON_KEY_EDIT_CARD_ID].asString();
	card_type_id = root[JSON_KEY_CARD_TYPE_ID].asInt();
	edit_type_id = root[JSON_KEY_EDIT_EDIT_TYPE_ID].asInt();

	CardMap::iterator it_card = mp_card_list_help.find(cardid);
	if(it_card != mp_card_list_help.end()){
		it_card->second->status_help = STATUS_ERROR_DEALED;
	}
	strlog.Format(_T("%s%s"), _T(LOG_DEAL_HELP), _T(LOG_SUCCESS));
	show_log(strlog);
}

void CYAServerDlg::deal_call_edit_map(int id, EDIT_TYPE_ID edit_type_id)
{
	CString strlog;
	switch (edit_type_id)
	{
	case ET_INSERT:
		{
			init_map(id);
			break;
		}
	case ET_UPDATE:
		{
			init_map(id);
			break;
		}
	case ET_DELETE:
		{
			MapInfoMap::iterator it_map = mp_map_list.find(id);
			if(it_map != mp_map_list.end()){
				mp_map_list.erase(it_map);
			}
			break;
		}
	default:
		break;
	}
	strlog.Format(_T("%s%s"), _T(LOG_EDIT_MAP), _T(LOG_SUCCESS));
	show_log(strlog);
}

void CYAServerDlg::deal_call_edit_area(int id, EDIT_TYPE_ID edit_type_id)
{
	CString strlog;
	switch (edit_type_id)
	{
	case ET_INSERT:
		{
			init_area(id);
			break;
		}
	case ET_UPDATE:
		{
			init_area(id);
			break;
		}
	case ET_DELETE:
		{
			AreaMap::iterator it_area = mp_area_list.find(id);
			MapInfoMap::iterator it_map = mp_map_list.find(it_area->second->map_id);
			if(it_map != mp_map_list.end()){
				AreaMap::iterator it_map_area = it_map->second->map_area_list.find(id);
				it_map->second->map_area_list.erase(it_map_area);
			}
			if(it_area != mp_area_list.end()){
				mp_area_list.erase(it_area);
			}

			it_area = mp_area_over_count_person.find(id);
			if(it_area != mp_area_over_count_person.end()){
				mp_area_over_count_person.erase(it_area);
			}
			it_area = mp_area_over_time_person.find(id);
			if(it_area != mp_area_over_time_person.end()){
				mp_area_over_time_person.erase(it_area);
			}
			it_area = mp_area_forbidden_person.find(id);
			if(it_area != mp_area_forbidden_person.end()){
				mp_area_forbidden_person.erase(it_area);
			}
			it_area = mp_area_over_count_vehicle.find(id);
			if(it_area != mp_area_over_count_vehicle.end()){
				mp_area_over_count_vehicle.erase(it_area);
			}
			it_area = mp_area_over_time_vehicle.find(id);
			if(it_area != mp_area_over_time_vehicle.end()){
				mp_area_over_time_vehicle.erase(it_area);
			}
			it_area = mp_area_forbidden_vehicle.find(id);
			if(it_area != mp_area_forbidden_vehicle.end()){
				mp_area_forbidden_vehicle.erase(it_area);
			}
			break;
		}
	default:
		break;
	}
	strlog.Format(_T("%s%s"), _T(LOG_EDIT_AREA), _T(LOG_SUCCESS));
	show_log(strlog);
}

void CYAServerDlg::deal_call_edit_reader(int id, EDIT_TYPE_ID edit_type_id)
{
	CString strlog;
	switch (edit_type_id)
	{
	case ET_INSERT:
		{
			init_reader(id);
			init_antenna(id);
			init_all_readers_coverage(id);
			break;
		}
	case ET_UPDATE:
		{
			init_reader(id);
			init_reader(id);
			init_all_readers_coverage(id);
			break;
		}
	case ET_DELETE:
		{
			ReaderMap::iterator it_reader = mp_reader_list.find(id);
			MapInfoMap::iterator it_map = mp_map_list.find(it_reader->second->map_id);
			if(it_map != mp_map_list.end()){
				ReaderMap::iterator it_map_reader = it_map->second->map_reader_list.find(id);
				if(it_map_reader != it_map->second->map_reader_list.end()){
					it_map->second->map_reader_list.erase(it_map_reader);
				}
			}
			if(it_reader != mp_reader_list.end()){
				mp_reader_list.erase(it_reader);
			}
			break;
		}
	default:
		break;
	}
	strlog.Format(_T("%s%s"), _T(LOG_EDIT_READER), _T(LOG_SUCCESS));
	show_log(strlog);
}

void CYAServerDlg::deal_call_edit_card(string id, EDIT_TYPE_ID edit_type_id)
{
	CString strlog;
	CardMap::iterator it_card = mp_card_list_all.find(id);
	if(it_card == mp_card_list_all.end()){
		return;
	}
	int card_type_id = it_card->second->card_type;
	switch (edit_type_id)
	{
	case ET_INSERT:
		{
			if(CT_VEHICLE == card_type_id){
				init_vehicle(id, true);
			}else if(CT_PERSON == card_type_id) {
				init_staffer(id, true);
			}
			break;
		}
	case ET_UPDATE:
		{
			if(CT_VEHICLE == card_type_id){
				init_vehicle(id, true);
			}else if(CT_PERSON == card_type_id) {
				init_staffer(id, true);
			}
			break;
		}
	case ET_DELETE:
		{
			remove_card(id);
			break;
		}
	default:
		break;
	}
	strlog.Format(_T("%s%s"), _T(LOG_EDIT_CARD), _T(LOG_SUCCESS));
	show_log(strlog);
}

void CYAServerDlg::deal_call_edit_staff(string id, EDIT_TYPE_ID edit_type_id)
{
	CString strlog;
	switch (edit_type_id)
	{
	case ET_INSERT:
		{
			init_staffer(id);
			break;
		}
	case ET_UPDATE:
		{
			init_staffer(id);
			break;
		}
	case ET_DELETE:
		{
			string cardid = "";
			CardMap::iterator it_card = mp_card_list_down_person.begin();
			for(; it_card != mp_card_list_down_person.end(); ++it_card){
				if(it_card->second->id == id){
					cardid = it_card->second->card_id;
					break;
				}
			}
			remove_card(cardid);
			break;
		}
	default:
		break;
	}
	strlog.Format(_T("%s%s"), _T(LOG_EDIT_STAFFER), _T(LOG_SUCCESS));
	show_log(strlog);
}

void CYAServerDlg::deal_call_edit_vehicle(string id, EDIT_TYPE_ID edit_type_id)
{
	CString strlog;
	switch (edit_type_id)
	{
	case ET_INSERT:
		{
			init_vehicle(id);
			break;
		}
	case ET_UPDATE:
		{
			init_vehicle(id);
			break;
		}
	case ET_DELETE:
		{
			string cardid = "";
			CardMap::iterator it_card = mp_card_list_down_vehicle.begin();
			for(; it_card != mp_card_list_down_vehicle.end(); ++it_card){
				if(it_card->second->id == id){
					cardid = it_card->second->card_id;
					break;
				}
			}
			remove_card(cardid);
			break;
		}
	default:
		break;
	}
	strlog.Format(_T("%s%s"), _T(LOG_EDIT_VEHICLE), _T(LOG_SUCCESS));
	show_log(strlog);
}

void CYAServerDlg::remove_card( string card_id )
{
	if(card_id.length() == 0)
		return;
	int card_type_id = 0;
	CardMap::iterator it_card = mp_card_list_all.find(card_id);
	if(it_card == mp_card_list_all.end()){
		return;
	}
	card_type_id = it_card->second->card_type;
	mp_card_list_all.erase(it_card);
	MapInfoMap::iterator it_map = mp_map_list.find(it_card->second->map_id);
	if(it_map != mp_map_list.end()){
		if(CT_VEHICLE == card_type_id){
			CardMap::iterator it_map_card = it_map->second->map_card_list_vehicle.find(card_id);
			if(it_map_card != it_map->second->map_card_list_vehicle.end()){
				it_map->second->map_card_list_vehicle.erase(it_map_card);
			}
		}else if(CT_PERSON == card_type_id){
			CardMap::iterator it_map_card = it_map->second->map_card_list_person.find(card_id);
			if(it_map_card != it_map->second->map_card_list_person.end()){
				it_map->second->map_card_list_person.erase(it_map_card);
			}
		}
	}
	AreaMap::iterator it_area = mp_area_list.find(it_card->second->area_id);
	if(it_area != mp_area_list.end()){
		if(CT_VEHICLE == card_type_id){
			CardMap::iterator it_area_card = it_area->second->area_card_list_vehicle.find(card_id);
			if(it_area_card != it_area->second->area_card_list_vehicle.end()){
				it_area->second->area_card_list_vehicle.erase(it_area_card);
			}
		}else if(CT_PERSON == card_type_id){
			CardMap::iterator it_area_card = it_area->second->area_card_list_person.find(card_id);
			if(it_area_card != it_area->second->area_card_list_person.end()){
				it_area->second->area_card_list_person.erase(it_area_card);
			}
		}
	}
	DeptMap::iterator it_dept = mp_dept_list.find(it_card->second->dept_id);
	if(it_dept != mp_dept_list.end()){
		if(CT_VEHICLE == card_type_id){
			CardMap::iterator it_dept_card = it_dept->second->dept_card_list_vehicle.find(card_id);
			if(it_dept_card != it_dept->second->dept_card_list_vehicle.end()){
				it_dept->second->dept_card_list_vehicle.erase(it_dept_card);
			}
		}else if(CT_PERSON == card_type_id){
			CardMap::iterator it_dept_card = it_dept->second->dept_card_list_person.find(card_id);
			if(it_dept_card != it_dept->second->dept_card_list_person.end()){
				it_dept->second->dept_card_list_person.erase(it_dept_card);
			}
		}
	}
	if(CT_VEHICLE == card_type_id){
		it_card = mp_card_list_down_vehicle.find(card_id);
		if(it_card != mp_card_list_down_vehicle.end()){
			mp_card_list_down_vehicle.erase(it_card);
		}
		it_card = mp_card_list_forbidden_vehicle.find(card_id);
		if(it_card != mp_card_list_forbidden_vehicle.end()){
			mp_card_list_forbidden_vehicle.erase(it_card);
		}
		it_card = mp_card_list_over_time_vehicle.find(card_id);
		if(it_card != mp_card_list_over_time_vehicle.end()){
			mp_card_list_over_time_vehicle.erase(it_card);
		}
		it_card = mp_card_list_area_over_time_vehicle.find(card_id);
		if(it_card != mp_card_list_area_over_time_vehicle.end()){
			mp_card_list_area_over_time_vehicle.erase(it_card);
		}
		it_card = mp_card_list_over_speed_vehicle.find(card_id);
		if(it_card != mp_card_list_over_speed_vehicle.end()){
			mp_card_list_over_speed_vehicle.erase(it_card);
		}
	}else if(CT_PERSON == card_type_id) {
		it_card = mp_card_list_down_person.find(card_id);
		if(it_card != mp_card_list_down_person.end()){
			mp_card_list_down_person.erase(it_card);
		}
		it_card = mp_card_list_over_time_person.find(card_id);
		if(it_card != mp_card_list_over_time_person.end()){
			mp_card_list_over_time_person.erase(it_card);
		}
		it_card = mp_card_list_forbidden_person.find(card_id);
		if(it_card != mp_card_list_forbidden_person.end()){
			mp_card_list_forbidden_person.erase(it_card);
		}
		it_card = mp_card_list_help.find(card_id);
		if(it_card != mp_card_list_help.end()){
			mp_card_list_help.erase(it_card);
		}
		it_card = mp_card_list_area_over_time_person.find(card_id);
		if(it_card != mp_card_list_area_over_time_person.end()){
			mp_card_list_area_over_time_person.erase(it_card);
		}
	}
}

void CYAServerDlg::save_card_postion( Card* card )
{
	// 位置发生变化
	double moved_dist = sqrt(pow(card->x - card->last_x, 2) + pow(card->y - card->last_y, 2) + 
		pow(card->z - card->last_z, 2));
	//if( moved_dist < card->map_scale/2.0){
	//	return ;
	//}
	//if(moved_dist > CM_PIX * 20){ //移动距离大于20m,认为出错
	//	card->x = card->last_x;
	//	card->y = card->last_y;
	//	card->z = card->last_z;
	//	return;
	//}
	// 位置变化幅度大于1m
	card->last_x = card->x;
	card->last_y = card->y;
	card->last_z = card->z;	
	card->is_first_location = false;
	store_data_card(card, HIS_LOCATION);
}

void CYAServerDlg::store_data_area( Area* area, time_t cur_time, time_t start_time, int tag )
{
	char sql[LENGTH_SQL] = {'\0'};
	char _time[STR_LEN_TIME], _time_ex[STR_LEN_TIME];
	struct tm local_time, local_time_ex;
	localtime_s(&local_time, &cur_time);
	localtime_s(&local_time_ex, &start_time);
	strftime(_time, 30, "%Y-%m-%d %H:%M:%S", &local_time);
	strftime(_time_ex, 30, "%Y-%m-%d %H:%M:%S", &local_time_ex);
	switch(tag){

	case ALARM_AREA_OVER_COUNT_PERSON_START:
		{
			int alarm_type_id = ATID_AREA_OVER_COUNT_PERSON;
			sprintf_s(sql, LENGTH_SQL, "INSERT INTO his_alarm_area(area_id, alarm_type_id, start_time) VALUES(%d, %d, '%s');",
				area->area_id, alarm_type_id, _time);
			break;
		}
	case ALARM_AREA_OVER_COUNT_PERSON_END:
		{
			localtime_s(&local_time_ex, &area->time_over_count_person);
			strftime(_time_ex, 30, "%Y-%m-%d %H:%M:%S", &local_time_ex);

			int alarm_type_id = ATID_AREA_OVER_COUNT_PERSON;
			sprintf_s(sql, LENGTH_SQL,
				"UPDATE his_alarm_area SET end_time = '%s' WHERE area_id=%d AND alarm_type_id=%d AND start_time = '%s';",
				_time, area->area_id, alarm_type_id, _time_ex);
			break;
		}
	default:
		return;
	}
	execute_sql(sql);
}

void CYAServerDlg::store_data_reader( Reader* reader, int tag )
{
	char sql[LENGTH_SQL] = {'\0'};
	char _time[STR_LEN_TIME], _time_ex[STR_LEN_TIME];
	struct tm local_time, local_time_ex;
	localtime_s(&local_time, &reader->lost_time);
	localtime_s(&local_time_ex, &reader->rec_time);
	strftime(_time, 30, "%Y-%m-%d %H:%M:%S", &local_time);
	strftime(_time_ex, 30, "%Y-%m-%d %H:%M:%S", &local_time_ex);
	switch(tag){
	case ALARM_READER_LOST_START:
		{
			int alarm_type_id = ATID_READER;
			sprintf_s(sql, LENGTH_SQL, "INSERT INTO his_alarm_reader(reader_id, alarm_type_id, start_time, rec_time) VALUES(%d, %d, '%s', '%s');",
				reader->reader_id, alarm_type_id, _time, _time_ex);
			break;
		}
	case ALARM_READER_LOST_END:
		{			
			int alarm_type_id = ATID_READER;
			sprintf_s(sql, LENGTH_SQL, "UPDATE his_alarm_reader set end_time='%s' where reader_id=%d and alarm_type_id=%d and start_time='%s';",
				_time_ex, reader->reader_id, alarm_type_id, _time);
			break;
		}
	default:
		return;
	}
	execute_sql(sql);
}

void CYAServerDlg::execute_sql( const char* sql )
{
	//return ;

	//::AfxBeginThread(_ExecSql, (LPVOID)pSQLData);
	CMysqlConn* pConn = NULL;
	CDBConnGuard pDbGuard(pConn);
	MYSQL_RES* pRes;
	int err = 0;
	pRes = pConn->Execute(sql, err);
	if(err){
		CString szLog;
		szLog.Format(_T("%s:\n%s"), _T(LOG_EXEC_SQL_ERROR), CFunctions::c2wc(sql));
		show_log(szLog);
	}
	mysql_free_result(pRes);
}

void CYAServerDlg::OnMenuLog()
{
	CLogSetting dlg;
	dlg.DoModal();
}

void CYAServerDlg::OnMenuParam()
{
	CSysSetting dlg;
	dlg.DoModal();
}

void CYAServerDlg::OnLogin( string const& name, message::ptr const& data, bool isAck, message::list &ack_resp )
{
	//	res_data ={
	//code: -1,
	//msg: '服务器错误，请联系系统管理员！',
	//data: {
	//name: user_name,
	//	  }
	//	}
	//_lock.lock();
	int res_code = (int)data->get_map()["code"]->get_int();
	switch (res_code)
	{
	case -1: // 用户未登录
		{
			ws_login();
			break;
		}
	case 0:
		{
			if("" == data->get_map()["code"]->get_string()){ // 登录成功
				is_websocket_login = true;
			}else{ // 退出登录
				is_websocket_login = false;
			}
			break;
		}
	default:
		break;
	}

	is_websocket_login = true;
	//bool plural = participants !=1;
	//HIGHLIGHT("Welcome to Socket.IO Chat-\nthere"<<(plural?" are ":"'s ")<< participants<<(plural?" participants":" participant"));
	//_cond.notify_all();
	//_lock.unlock();
	//current_socket->off("login");
}

void CYAServerDlg::OnLoginCallBack( message::list const& msglist /*= nullptr*/ )
{
	message::ptr msg_ptr = msglist[0];
	int n = (int)msg_ptr->get_map()["code"]->get_int();
	is_websocket_login = (0 == n) ? true : false;
}

void CYAServerDlg::send_call_info()
{	
	BYTE buf[LENGTH_SEND_BUF];
	//SocketMap::iterator it_sock;
	//CallInfoReaderMap::iterator it_call_reader = mp_call_info.begin();
	//for(; it_call_reader != mp_call_info.end(); ++it_call_reader){
	//	it_sock = mp_socket_list.find(it_call_reader->first);
	//	if(it_sock != mp_socket_list.end()){
	//		memset(buf, 0, LENGTH_SEND_BUF);
	//		int npos = 0, card_count = 0;

	//		memcpy(&buf[npos], &card_count, sizeof(BYTE));
	//		npos += sizeof(BYTE);
	//		memcpy(&buf[npos], &it_call_reader->second->call_type, sizeof(BYTE));
	//		npos += sizeof(BYTE);

	//		if(!it_call_reader->second->is_call_all){ // 定员呼叫，加入卡列表
	//			CallInfoCardMap::iterator it_call_card = it_call_reader->second->mpCard.begin();
	//			for(; it_call_card != it_call_reader->second->mpCard.end(); ++it_call_card){
	//				memcpy(&buf[npos], &it_call_card->second->call_type, sizeof(BYTE));
	//				npos += sizeof(BYTE);
	//				memcpy(&buf[npos], &it_call_card->second->card_type, sizeof(BYTE));
	//				npos += sizeof(BYTE);
	//				BYTE id_len = (BYTE)get_card_id_len(it_call_card->second->card_type);
	//				memcpy(&buf[npos], &id_len, sizeof(BYTE));
	//				npos += sizeof(BYTE);
	//				if(id_len > 1){ // 标准卡id为4个字节，自组网卡为1个字节
	//					CFunctions::memcpyDWord(buf,  it_call_card->second->card_id, npos);
	//				}else{
	//					memcpy(&buf[npos], &it_call_card->second->card_id, id_len);
	//				}
	//				npos += id_len;
	//				card_count++;
	//			}
	//			memcpy(&buf[0], &card_count, sizeof(BYTE));
	//		}
	//		it_sock->second->SendData(CHAR_CALL, npos, buf);
	//	}
	//}
}

void CYAServerDlg::clear_call_info()
{
	CallInfoReaderMap::iterator it_call_reader = mp_call_info.begin();
	time_t current_time = time_t(NULL);
	for(; it_call_reader != mp_call_info.end(); ++it_call_reader){
		if(it_call_reader->second->is_call_all){
		}else{
			CallInfoCardMap::iterator it_call_card = it_call_reader->second->mpCard.begin();
			for(; it_call_card != it_call_reader->second->mpCard.end(); ++it_call_card){
				if(difftime(current_time, it_call_card->second->start_time) > it_call_card->second->time_out * 60   ){
					it_call_reader->second->mpCard.erase(it_call_card);
				}
			}
		}
	}
}

int CYAServerDlg::get_card_id_len( int card_type )
{
	switch (card_type)
	{
		//case CT_PERSON:
		//	return 4;
		//case CT_VEHICLE:
		//	return 4;
	case CT_ADHOC:
		return 1;
	default:
		return 4;
		//break;
	}
}

std::string CYAServerDlg::get_json_call_test()
{
	Json::Value root;
	Json::Value val_data;
	Json::Value val_stations;
	Json::Value val_station;
	Json::Value val_cards;
	Json::Value val_card;

	char _time[STR_LEN_TIME];
	struct tm local_time;
	time_t tt = time(NULL);

	localtime_s(&local_time, &tt);
	strftime(_time, STR_LEN_TIME, "%Y-%m-%d %H:%M:%S", &local_time);
	val_data[JSON_KEY_CALL_CARD_CALL_TIME] = _time;
	val_data[JSON_KEY_CALL_CARD_CALL_TYPE] = 0;
	val_data[JSON_KEY_CALL_CARD_USER_NAME] = "aaaaaa";
	val_data[JSON_KEY_CALL_CARD_CALL_TIME_OUT] = 5;

	val_station[JSON_KEY_CALL_CARD_STATION_ID] = 233;
	val_stations.append(val_station);
	val_station[JSON_KEY_CALL_CARD_STATION_ID] = 59;
	val_stations.append(val_station);

	val_card[JSON_KEY_CALL_CARD_CARD_TYPE_ID] = 3;
	val_card[JSON_KEY_CALL_CARD_CARD_ID] = 5;
	val_cards.append(val_card);
	val_card[JSON_KEY_CALL_CARD_CARD_TYPE_ID] = 3;
	val_card[JSON_KEY_CALL_CARD_CARD_ID] = 8;
	val_cards.append(val_card);

	val_data[JSON_KEY_CALL_CARD_STATIONS] = val_stations;
	val_data[JSON_KEY_CALL_CARD_CARDS] = val_cards;

	root[JSON_ROOT_KEY_CMD] = JSON_CMD_VALUE_CALL_CARD_START;
	root[JSON_ROOT_KEY_DATA] = val_data;
	return root.toFastString();
}

void CYAServerDlg::init_base_data()
{
	init_setting();
	init_alarm_type();
	init_dept();
	init_card();
	init_staffer();
	init_vehicle();
	init_map();
	init_area();
	init_reader();
	init_antenna();
	init_all_readers_coverage();
	init_tdoa_all_readers_coverage();
	init_dev_adhoc();
	init_antenna_sync();
}

void CYAServerDlg::load_his_data()
{
	//load_his_down(); // 入井状态
	//load_his_area(); // 所在区域
	load_his_reader(); // 分站状态
	load_his_card_postion(); // 所在位置
	load_his_card_state();
	deal_hist_card_postion();
}

void CYAServerDlg::load_his_down()
{

}

void CYAServerDlg::load_his_area()
{
	CMysqlConn* pConn = NULL;
	CDBConnGuard pDbGuard(pConn);
	MYSQL_RES* pRes;
	MYSQL_ROW pRow;
	int err = 0;
	char buf[LENGTH_SQL] = {0};
	sprintf_s(buf, "select la.card_id, la.area_id, la.map_id, la.enter_time from his_location_area la, \
				   (select card_id, max(enter_time) enter_time from his_location_area where leave_time is null group by(card_id)) lax \
				   where la.card_id = lax.card_id and la.enter_time = lax.enter_time;");
	pRes = pConn->Execute(buf, err);
	int nRow = 0;
	std::string enter_time;
	while(pRow = mysql_fetch_row(pRes)){
		CardMap::iterator it = mp_card_list_all.find(pRow[0]);
		if(it != mp_card_list_all.end()){
			it->second->area_id = atoi(pRow[1]);
			it->second->map_id = atoi(pRow[2]);
			enter_time = pRow[3];
			API_StringToTime(enter_time, it->second->enter_area_time);
			nRow++;
		}
	}
	mysql_free_result(pRes);
	CString strlog;
	strlog.Format(_T("%s%d%s"), _T(LOG_LOAD_HIS_AREA), nRow, _T(LOG_RECORD_COUNT));
	show_log(strlog);
}

void CYAServerDlg::load_his_card_postion()
{
	CMysqlConn* pConn = NULL;
	CDBConnGuard pDbGuard(pConn);
	MYSQL_RES* pRes;
	MYSQL_ROW pRow;
	int err = 0;
	char buf[LENGTH_SQL] = {0};
	sprintf_s(buf, "select l.card_id, l.cur_time, l.x, l.y, l.z, la.map_id, la.area_id, la.enter_time, att.start_time \
				   from his_location l, (select card_id, max(cur_time) cur_time from his_location group by card_id) lx, \
				   (select la.* from his_location_area la, (select card_id, max(enter_time) enter_time from his_location_area group by card_id) lax \
				   where la.card_id = lax.card_id and la.enter_time = lax.enter_time and la.leave_time is null) la, \
				   (select att.* from rpt_attendance att, (select card_id, max(start_time) start_time from rpt_attendance group by card_id) attx \
				   where att.card_id = attx.card_id and att.start_time = attx. start_time and att.end_time is null) att \
				   where l.card_id = lx.card_id and l.cur_time = lx.cur_time \
				   and l.card_id = la.card_id  and l.area_id = la.area_id and l.cur_time >= la.enter_time \
				   and l.card_id = att.card_id and l.cur_time >= att.start_time;");
	pRes = pConn->Execute(buf, err);
	int nRow = 0;
	std::string rec_time, enter_time, start_time;
	while(pRow = mysql_fetch_row(pRes)){
		CardMap::iterator it = mp_card_list_all.find(pRow[0]);
		if(it != mp_card_list_all.end()){
			rec_time = pRow[1];
			API_StringToTime(rec_time, it->second->rec_time);
			it->second->x = atof(pRow[2]);
			it->second->y = atof(pRow[3]);
			it->second->z = atof(pRow[4]);
			it->second->area_id = atoi(pRow[5]);
			it->second->map_id = atoi(pRow[6]);
			enter_time = pRow[7];
			API_StringToTime(enter_time, it->second->enter_area_time);
			start_time = pRow[8];
			API_StringToTime(start_time, it->second->down_time);
			it->second->pos_state = DT_DOWN;
			it->second->pos_state_old = DT_DOWN;
			//it->second->deal_time = time(NULL);
			it->second->is_hist = true;
			//it->second->isdealed = true;
			//it->second->issent = false;
			nRow++;

			//card_down_mine(it->second, true);
			//card_enter_map(it->second, true);
			//card_enter_area(it->second, true);

			//if(it->second->card_type == CT_VEHICLE){
			//	mp_card_list_down_vehicle.insert(make_pair(it->second->card_id, it->second)); 
			//}else if(it->second->card_type == CT_PERSON){
			//	mp_card_list_down_person.insert(make_pair(it->second->card_id, it->second));
			//}
		}
	}
	mysql_free_result(pRes);
	CString strlog;
	strlog.Format(_T("%s%d%s"), _T(LOG_LOAD_HIS_POSTION), nRow, _T(LOG_RECORD_COUNT));
	show_log(strlog);
}

int CYAServerDlg::API_TimeToString( string &strDateStr,const time_t &timeData )
{
	char chTmp[100] = {0};
	memset(chTmp, 0, sizeof(chTmp));
	struct tm *p = 0;
	localtime_s(p, &timeData);
	//p = localtime(&timeData);
	p->tm_year = p->tm_year + 1900;
	p->tm_mon = p->tm_mon + 1;
	sprintf_s(chTmp,sizeof(chTmp),"%.4d-%.2d-%.2d %.2d:%.2d:%.2d",
		p->tm_year, p->tm_mon, p->tm_mday,p->tm_hour,p->tm_min,p->tm_sec);
	strDateStr = chTmp;
	return 0;
}

int CYAServerDlg::API_StringToTime( const string &strDateStr,time_t &timeData )
{
	char *pBeginPos = (char*) strDateStr.c_str();
	char *pPos = strstr(pBeginPos,"-");
	if(pPos == NULL){
		//printf("strDateStr[%s] err /n", strDateStr.c_str());
		return -1;
	}
	int iYear = atoi(pBeginPos);
	int iMonth = atoi(pPos + 1);
	pPos = strstr(pPos + 1,"-");
	if(pPos == NULL){
		//printf("strDateStr[%s] err /n", strDateStr.c_str());
		return -1;
	}
	int iDay = atoi(pPos + 1);
	int iHour=0;
	int iMin=0;
	int iSec=0;
	pPos = strstr(pPos + 1," ");
	//为了兼容有些没精确到时分秒的
	if(pPos != NULL){
		iHour=atoi(pPos + 1);
		pPos = strstr(pPos + 1,":");
		if(pPos != NULL){
			iMin=atoi(pPos + 1);
			pPos = strstr(pPos + 1,":");
			if(pPos != NULL){
				iSec=atoi(pPos + 1);
			}
		}
	}
	struct tm sourcedate;
	memset((void*)&sourcedate, 0, sizeof(sourcedate));
	sourcedate.tm_sec = iSec;
	sourcedate.tm_min = iMin;
	sourcedate.tm_hour = iHour;
	sourcedate.tm_mday = iDay;
	sourcedate.tm_mon = iMonth - 1;
	sourcedate.tm_year = iYear - 1900;
	timeData = mktime(&sourcedate);
	return 0;
}

int CYAServerDlg::init_card( string card_id /*= ""*/ )
{
	CMysqlConn* pConn = NULL;
	CDBConnGuard pDbGuard(pConn);
	MYSQL_RES* pRes;
	MYSQL_ROW pRow;
	int err = 0;
	char buf[LENGTH_SQL] = {0};
	if(card_id.length() == 0){
		sprintf_s(buf, "select card_id, card_type_id, state, is_count, ident from dat_card where state = 0;");
	}else{
		sprintf_s(buf, "select card_id, card_type_id, state, is_count, ident from dat_card where state = 0 and card_id='%s';", card_id.c_str());
	}
	pRes = pConn->Execute(buf, err);
	Card* pCard = NULL;
	int nRow = 0;
	while(pRow = mysql_fetch_row(pRes)){
		CardMap::iterator it = mp_card_list_all.find(pRow[0]);
		if(it != mp_card_list_all.end()){
			pCard = it->second;
		}else{
			pCard = new Card(pRow[0], atoi(pRow[1]), theApp.z_offset);
			mp_card_list_all.insert(make_pair(pCard->card_id, pCard));
			nRow++;
		}
	}
	mysql_free_result(pRes);
	CString strlog;
	strlog.Format(_T("%s%d%s"), _T(LOG_INIT_CARD), nRow, _T(LOG_RECORD_COUNT));
	show_log(strlog);
	return 0;
}

void CYAServerDlg::card_up_mine( Card* card )
{
	card->up_time = card->deal_time;
	store_data_card(card, RPT_ATTEND_UP);
	if(CT_PERSON == card->card_type){
		CardMap::iterator it_card = mp_card_list_down_person.find(card->card_id);
		if(it_card != mp_card_list_down_person.end()){
			mp_card_list_down_person.erase(it_card); // 从井下卡列表删除
		}
		if(mp_card_list_down_person.size() <= sls_setting.over_count_person && time_over_count_person >0){ // 取消报警
			store_data_mine(ALARM_MINE_OVER_COUNT_PERSON_END);
			time_over_count_person = 0;
		}
	}else if(CT_VEHICLE == card->card_type){
		CardMap::iterator it_card = mp_card_list_down_vehicle.find(card->card_id);
		if(it_card != mp_card_list_down_vehicle.end()){
			mp_card_list_down_vehicle.erase(it_card); // 从井下卡列表删除
		}
		if(mp_card_list_down_vehicle.size() < sls_setting.over_count_vehicle && time_over_count_vehicle > 0){
			store_data_mine(ALARM_MINE_OVER_COUNT_VEHICLE_END);
			time_over_count_vehicle = 0;
		}
	}

	DeptMap::iterator it_dept = mp_dept_list.find(card->dept_id);
	if(it_dept != mp_dept_list.end()){
		if(CT_PERSON == card->card_type){
			CardMap::iterator it_card = it_dept->second->dept_card_list_person.find(card->card_id);
			if(it_card != it_dept->second->dept_card_list_person.end()){
				it_dept->second->dept_card_list_person.erase(it_card); // 从井下卡列表删除
			}
			store_data_card(card, ALARM_CARD_OVER_TIME_END);
			deal_alarm_card(card, &mp_card_list_over_time_person, false, AF_CARD_OVER_TIME);
		}else if(CT_VEHICLE == card->card_type){
			CardMap::iterator it_card = it_dept->second->dept_card_list_vehicle.find(card->card_id);
			if(it_card != it_dept->second->dept_card_list_vehicle.end()){
				it_dept->second->dept_card_list_vehicle.erase(it_card); // 从井下卡列表删除
			}
			store_data_card(card, ALARM_CARD_OVER_TIME_END);
			deal_alarm_card(card, &mp_card_list_over_time_vehicle, false, AF_CARD_OVER_TIME);
		}
	}
}

void CYAServerDlg::card_down_mine( Card* card )
{
	card->down_time = card->deal_time;
	if(CT_PERSON == card->card_type){
		CardMap::iterator it_card = mp_card_list_down_person.find(card->card_id);
		if(it_card == mp_card_list_down_person.end()){
			mp_card_list_down_person.insert(make_pair(card->card_id, card)); // 添加到井下卡列表
		}
		if(time_over_count_person == 0 && mp_card_list_down_person.size() > sls_setting.over_count_person){
			time_over_count_person = time(NULL);
			store_data_mine(ALARM_MINE_OVER_COUNT_PERSON_START);
		}
	}else if(CT_VEHICLE == card->card_type){
		CardMap::iterator it_card = mp_card_list_down_vehicle.find(card->card_id);
		if(it_card == mp_card_list_down_vehicle.end()){
			mp_card_list_down_vehicle.insert(make_pair(card->card_id, card)); // 添加到井下卡列表
		}
		if(time_over_count_vehicle == 0 && mp_card_list_down_vehicle.size() > sls_setting.over_count_vehicle){
			time_over_count_vehicle = time(NULL);
			store_data_mine(ALARM_MINE_OVER_COUNT_VEHICLE_START);
		}
	}

	DeptMap::iterator it_dept = mp_dept_list.find(card->dept_id);
	if(it_dept != mp_dept_list.end()){
		if(CT_PERSON == card->card_type){
			CardMap::iterator it_card = it_dept->second->dept_card_list_person.find(card->card_id);
			if(it_card == it_dept->second->dept_card_list_person.end()){
				it_dept->second->dept_card_list_person.insert(make_pair(card->card_id, card)); // 添加到井下卡列表
			}
			// 判断是否超员
		}else if(CT_VEHICLE == card->card_type){
			CardMap::iterator it_card = it_dept->second->dept_card_list_vehicle.find(card->card_id);
			if(it_card == it_dept->second->dept_card_list_vehicle.end()){
				it_dept->second->dept_card_list_vehicle.insert(make_pair(card->card_id, card)); // 添加到井下卡列表
			}
			// 判断是否超员
		}
	}
	store_data_card(card, RPT_ATTEND_DOWN);
}

void CYAServerDlg::send_sync_reader()
{
	time_t cur_time;
	struct tm *local = 0;
	int wlen = 0;
	BYTE SendBuffer[LENGTH_SEND_BUF];
	BYTE bt_tmp;
	// 遍历发送数据
	//SocketMap::iterator it_sock = mp_socket_list.begin();
	//for(; it_sock != mp_socket_list.end(); ++it_sock){
	//	wlen = 0;
	//	cur_time = time(NULL);
	//	memset(SendBuffer, 0, LENGTH_SEND_BUF);
	//	localtime_s(local, &cur_time);
	//	//local=localtime(&cur_time);
	//	bt_tmp = local->tm_sec; 
	//	memcpy(&SendBuffer[wlen], &bt_tmp, sizeof(BYTE));
	//	wlen += sizeof(BYTE);
	//	bt_tmp = local->tm_min;
	//	memcpy(&SendBuffer[wlen], &bt_tmp, sizeof(BYTE));
	//	wlen += sizeof(BYTE);
	//	bt_tmp = local->tm_hour;
	//	memcpy(&SendBuffer[wlen], &bt_tmp, sizeof(BYTE));
	//	wlen += sizeof(BYTE);
	//	bt_tmp = local->tm_mday; 
	//	memcpy(&SendBuffer[wlen], &bt_tmp, sizeof(BYTE));
	//	wlen += sizeof(BYTE);
	//	bt_tmp = local->tm_wday;
	//	memcpy(&SendBuffer[wlen], &bt_tmp, sizeof(BYTE));
	//	wlen += sizeof(BYTE);
	//	bt_tmp = local->tm_mon + 1;
	//	memcpy(&SendBuffer[wlen], &bt_tmp, sizeof(BYTE));
	//	wlen += sizeof(BYTE);
	//	bt_tmp = (local->tm_year + 1900)%100;
	//	memcpy(&SendBuffer[wlen], &bt_tmp, sizeof(BYTE));
	//	wlen += sizeof(BYTE);
	//	it_sock->second->SendData(CHAR_SYNC_TIME, wlen, &SendBuffer[0]);
	//	Sleep(20);
	//}
}

void CYAServerDlg::send_call_his_data()
{
	if (MessageBox(_T("确定要接收历史数据吗？"), _T("接收历史数据"), MB_OKCANCEL) != IDOK){
		return;
	}
	//SocketMap::iterator it_sock = mp_socket_list.begin();
	//for(; it_sock != mp_socket_list.end(); ++it_sock){
	//	it_sock->second->SendData(CHAR_LOCATEDATAHIS, 0, NULL);
	//	Sleep(20);
	//}
}

void CYAServerDlg::OnBnCallHisData()
{
	send_call_his_data();
}

void CYAServerDlg::deal_hist_card_postion()
{
	CardMap::iterator it_card = mp_card_list_all.begin();
	for(; it_card != mp_card_list_all.end(); ++it_card){
		if(it_card->second->is_hist){
			if(CT_VEHICLE == it_card->second->card_type){
				mp_card_list_down_vehicle.insert(make_pair(it_card->first, it_card->second));
				AreaMap::iterator it_area = mp_area_list.find(it_card->second->area_id);
				if(it_area != mp_area_list.end()){
					it_area->second->area_card_list_vehicle.insert(make_pair(it_card->first, it_card->second));
					if(0 == it_area->second->over_count_vehicle){
						mp_card_list_forbidden_vehicle.insert(make_pair(it_card->first, it_card->second));
					}
				}
				MapInfoMap::iterator it_map = mp_map_list.find(it_card->second->map_id);
				if(it_map != mp_map_list.end()){
					it_map->second->map_card_list_vehicle.insert(make_pair(it_card->first, it_card->second));
				}
			}else if(CT_PERSON == it_card->second->card_type){
				mp_card_list_down_person.insert(make_pair(it_card->first, it_card->second));
				AreaMap::iterator it_area = mp_area_list.find(it_card->second->area_id);
				if(it_area != mp_area_list.end()){
					it_area->second->area_card_list_person.insert(make_pair(it_card->first, it_card->second));
					if(0 == it_area->second->over_count_person){
						mp_card_list_forbidden_person.insert(make_pair(it_card->first, it_card->second));
					}
				}
				MapInfoMap::iterator it_map = mp_map_list.find(it_card->second->map_id);
				if(it_map != mp_map_list.end()){
					it_map->second->map_card_list_person.insert(make_pair(it_card->first, it_card->second));
				}
			}
		}
	}
}

void CYAServerDlg::deal_hist_card_alarm()
{
	//CardMap mp_card_list_forbidden_vehicle;
	//CardMap mp_card_list_over_time_vehicle;	
	//CardMap mp_card_list_over_speed_vehicle;
	//CardMap mp_card_list_area_over_time_vehicle;

	//CardMap mp_card_list_over_time_person; // 
	//CardMap mp_card_list_forbidden_person;
	//CardMap mp_card_list_help;
	//CardMap mp_card_list_area_over_time_person;
}

void CYAServerDlg::deal_hist_area()
{
	//AreaMap mp_area_over_count_person;
	//AreaMap mp_area_over_time_person;
	//AreaMap mp_area_forbidden_person;
	//AreaMap mp_area_over_count_vehicle;
	//AreaMap mp_area_over_time_vehicle;
	//AreaMap mp_area_forbidden_vehicle;
}

void CYAServerDlg::load_his_reader()
{
	CMysqlConn* pConn = NULL;
	CDBConnGuard pDbGuard(pConn);
	MYSQL_RES* pRes;
	MYSQL_ROW pRow;
	int err = 0;
	char buf[LENGTH_SQL] = {0};
	sprintf_s(buf, "select ar.reader_id, ar.start_time, ar.rec_time from his_alarm_reader ar,\
				   (select reader_id, max(start_time) as start_time from his_alarm_reader group by reader_id) arx \
				   where ar.reader_id = arx.reader_id and ar.start_time = arx.start_time and ar.end_time IS NULL");
	pRes = pConn->Execute(buf, err);
	int nRow = 0;
	std::string rec_time, lost_time;
	while(pRow = mysql_fetch_row(pRes)){
		ReaderMap::iterator it = mp_reader_list.find(atoi(pRow[0]));
		if(it != mp_reader_list.end()){
			lost_time = pRow[1];
			rec_time = pRow[2];
			API_StringToTime(rec_time, it->second->rec_time);
			API_StringToTime(lost_time, it->second->lost_time);
			it->second->state = STATUS_DEVICE_ERROR;
			nRow++;
		}
	}
	mysql_free_result(pRes);
	CString strlog;
	strlog.Format(_T("%s%d%s"), _T(LOG_LOAD_HIS_READER), nRow, _T(LOG_RECORD_COUNT));
	show_log(strlog);
}

void CYAServerDlg::store_data_mine( int tag )
{
	char sql[LENGTH_SQL] = {'\0'};
	char _time[STR_LEN_TIME], _time_ex[STR_LEN_TIME];
	time_t cur_time = time(NULL);
	struct tm local_time, local_time_ex;
	switch(tag){
	case ALARM_MINE_OVER_COUNT_PERSON_START:
		{
			localtime_s(&local_time, &time_over_count_person);
			localtime_s(&local_time_ex, &cur_time);
			strftime(_time, 30, "%Y-%m-%d %H:%M:%S", &local_time);
			strftime(_time_ex, 30, "%Y-%m-%d %H:%M:%S", &local_time_ex);

			int alarm_type_id = ATID_OVER_COUNT_PERSON;
			sprintf_s(sql, LENGTH_SQL, "INSERT INTO his_alarm_info(alarm_type_id, start_time) VALUES(%d, '%s');",
				alarm_type_id, _time);
			break;
		}
	case ALARM_MINE_OVER_COUNT_PERSON_END:
		{
			localtime_s(&local_time, &time_over_count_person);
			localtime_s(&local_time_ex, &cur_time);
			strftime(_time, 30, "%Y-%m-%d %H:%M:%S", &local_time);
			strftime(_time_ex, 30, "%Y-%m-%d %H:%M:%S", &local_time_ex);

			int alarm_type_id = ATID_OVER_COUNT_PERSON;
			sprintf_s(sql, LENGTH_SQL, "UPDATE his_alarm_info set end_time='%s' where alarm_type_id=%d and start_time='%s';",
				_time_ex, alarm_type_id, _time);
			break;
		}
	case ALARM_MINE_OVER_COUNT_VEHICLE_START:
		{
			localtime_s(&local_time, &time_over_count_vehicle);
			localtime_s(&local_time_ex, &cur_time);
			strftime(_time, 30, "%Y-%m-%d %H:%M:%S", &local_time);
			strftime(_time_ex, 30, "%Y-%m-%d %H:%M:%S", &local_time_ex);

			int alarm_type_id = ATID_OVER_COUNT_VEHICLE;
			sprintf_s(sql, LENGTH_SQL, "INSERT INTO his_alarm_info(alarm_type_id, start_time) VALUES(%d, '%s');",
				alarm_type_id, _time);
			break;
		}
	case ALARM_MINE_OVER_COUNT_VEHICLE_END:
		{
			localtime_s(&local_time, &time_over_count_vehicle);
			localtime_s(&local_time_ex, &cur_time);
			strftime(_time, 30, "%Y-%m-%d %H:%M:%S", &local_time);
			strftime(_time_ex, 30, "%Y-%m-%d %H:%M:%S", &local_time_ex);

			int alarm_type_id = ATID_OVER_COUNT_VEHICLE;
			sprintf_s(sql, LENGTH_SQL, "UPDATE his_alarm_info set end_time='%s' where alarm_type_id=%d and start_time='%s';",
				_time_ex, alarm_type_id, _time);
			break;
		}
	default:
		return;
	}
	execute_sql(sql);
}

void CYAServerDlg::deal_card_state( Card* card )
{
	// 电量
	if(card->power_state == 0 && card->power_state_last != 0){
		card->status_power = STATUS_NORMAL;
		store_data_card(card, ALARM_CARD_LOW_POWER_END);
	}
	if(card->power_state_last == 0 && card->power_state != 0){
		card->low_power_time = card->deal_time;
		store_data_card(card, ALARM_CARD_LOW_POWER_START);
	}
	card->power_state_last = card->power_state;
}

void CYAServerDlg::load_his_card_state()
{
	CMysqlConn* pConn = NULL;
	CDBConnGuard pDbGuard(pConn);
	MYSQL_RES* pRes;
	MYSQL_ROW pRow;
	int err = 0;
	char buf[LENGTH_SQL] = {0};
	sprintf_s(buf, "select ac.card_id, ac.alarm_type_id, ac.start_time from his_alarm_card ac, \
				   (select card_id, max(start_time) start_time, alarm_type_id from his_alarm_card group by card_id, alarm_type_id) acx \
				   where ac.card_id = acx.card_id and ac.alarm_type_id=acx.alarm_type_id and ac.start_time=acx.start_time and ac.end_time is NULL;");
	pRes = pConn->Execute(buf, err);
	int nRow = 0;
	std::string start_time;
	while(pRow = mysql_fetch_row(pRes)){
		CardMap::iterator it = mp_card_list_all.find(pRow[0]);
		if(it != mp_card_list_all.end()){
			switch (atoi(pRow[1]))
			{
			case ATID_POWER:
				it->second->power_state = 1;
				it->second->power_state_last = 1;
				it->second->status_power = STATUS_ERROR;
				start_time = pRow[2];
				API_StringToTime(start_time, it->second->low_power_time);
			default:
				break;
			}
			nRow++;
		}
	}
	mysql_free_result(pRes);
	CString strlog;
	strlog.Format(_T("%s%d%s"), _T(LOG_LOAD_HIS_STATE), nRow, _T(LOG_RECORD_COUNT));
	show_log(strlog);
}

EnHandleResult CYAServerDlg::OnPrepareListen( SOCKET soListen )
{
	TCHAR szAddress[40];
	int iAddressLen = sizeof(szAddress) / sizeof(TCHAR);
	USHORT usPort;
	_server.GetListenAddress(szAddress, iAddressLen, usPort);
	::PostOnPrepareListen(szAddress, usPort);
	return HR_OK;
}

EnHandleResult CYAServerDlg::OnAccept( CONNID dwConnID, SOCKET soClient )
{
	BOOL bPass = TRUE;

	TCHAR szAddress[40];
	int iAddressLen = sizeof(szAddress) / sizeof(TCHAR);
	USHORT usPort;
	_server.GetRemoteAddress(dwConnID, szAddress, iAddressLen, usPort);

	::PostOnAccept(dwConnID, szAddress, usPort, bPass);
	return bPass ? HR_OK : HR_ERROR;
}

EnHandleResult CYAServerDlg::OnSend( CONNID dwConnID, const BYTE* pData, int iLength )
{
	::PostOnSend(dwConnID, pData, iLength);
	return HR_OK;
}

EnHandleResult CYAServerDlg::OnReceive( CONNID dwConnID, const BYTE* pData, int iLength )
{
	::PostOnReceive(dwConnID, pData, iLength);
	parse_data(pData, iLength, dwConnID);
	return HR_OK;
}

EnHandleResult CYAServerDlg::OnClose( CONNID dwConnID, EnSocketOperation enOperation, int iErrorCode )
{
	remove_socket(dwConnID);

	iErrorCode == SE_OK ? ::PostOnClose(dwConnID):
		::PostOnError(dwConnID, enOperation, iErrorCode);
	return HR_OK;
}

EnHandleResult CYAServerDlg::OnShutdown()
{
	::PostOnShutdown();
	return HR_OK;
}

_SOCK* CYAServerDlg::get_socket_by_count( DWORD dwConnID )
{
	SocketMap::iterator _sock = mp_socket_list.begin();
	for(; _sock != mp_socket_list.end(); ++_sock){
		if(_sock->second->dwConnID == dwConnID){
			return _sock->second;
		}
	}
	return NULL;
}


afx_msg LRESULT CYAServerDlg::OnMsgRefreshIpList(WPARAM wParam, LPARAM lParam)
{
	m_listctrl_reader.DeleteAllItems();
	SocketMap::iterator it_sock = mp_socket_list.begin();
	for(; it_sock != mp_socket_list.end(); ++it_sock){
		AddItem(it_sock->second->sip, it_sock->second->reader_id, it_sock->second->state);
	}
	return 0;
}

void CYAServerDlg::parse_data_locate_card_his( BYTE* DataBuffer, int& nCurPos, int reader_id, DWORD wTickCount, CString strTime, unsigned short wChr)
{
	// 按时间分组解析
	// 组长度
	WORD wframelen  = 0;
	CFunctions::getWord(DataBuffer, &wframelen, nCurPos);
	nCurPos += sizeof(WORD);
	int nframepos = nCurPos;

	// 数据保存时间 7字节，年，月，周，日，时，分，秒
	BYTE btSec = 0;
	memcpy(&btSec, &DataBuffer[nCurPos], sizeof(BYTE));
	nCurPos += sizeof(BYTE);
	BYTE btMin = 0;
	memcpy(&btMin, &DataBuffer[nCurPos], sizeof(BYTE));
	nCurPos += sizeof(BYTE);
	BYTE btHour = 0;
	memcpy(&btHour, &DataBuffer[nCurPos], sizeof(BYTE));
	nCurPos += sizeof(BYTE);
	BYTE btDay = 0;
	memcpy(&btDay, &DataBuffer[nCurPos], sizeof(BYTE));
	nCurPos += sizeof(BYTE);
	BYTE btWeek = 0;
	memcpy(&btWeek, &DataBuffer[nCurPos], sizeof(BYTE));
	nCurPos += sizeof(BYTE);
	BYTE btMonth = 0;
	memcpy(&btMonth, &DataBuffer[nCurPos], sizeof(BYTE));
	nCurPos += sizeof(BYTE);
	BYTE btYear = 0;
	memcpy(&btYear, &DataBuffer[nCurPos], sizeof(BYTE));
	nCurPos += sizeof(BYTE);

	CString strhistime;
	strhistime.Format(_T("20%.2d-%.2d-%.2d %.2d:%.2d:%.2d"), btYear%100, btMonth, btDay, btHour, btMin, btSec );				

	while(nCurPos - nframepos < wframelen){ // 一组数据
		BYTE btCardType = 0;
		memcpy(&btCardType, &DataBuffer[nCurPos], sizeof(BYTE));
		nCurPos += sizeof(BYTE);

		DWORD dwCardId = 0;
		CFunctions::getDWord(DataBuffer, &dwCardId, nCurPos);
		nCurPos += sizeof(DWORD);

		string str_card_id = CFunctions::getstrwithzero(btCardType, 3) + CFunctions::getstrwithzero(dwCardId, 10);
		Card* pCard = new Card(str_card_id, btCardType, theApp.z_offset);

		pCard->reader_id = reader_id;
		pCard->str_his_time = CFunctions::wc2c(strhistime);
		pCard->reader_tickcount = wTickCount;
		pCard->str_rec_time = CFunctions::wc2c(strTime);

		//LONG64 l64cardid = btCardType;
		//l64cardid <<= 32;
		//l64cardid |= dwCardId;

		switch(btCardType)
		{
		case CT_VEHICLE:
			{
				//报文时间
				WORD wCardTickCount = 0;
				CFunctions::getWord(DataBuffer, &wCardTickCount, nCurPos);
				nCurPos += sizeof(WORD);

				pCard->time_stamp = wCardTickCount;

				BYTE btTypeAndPower = 0;
				memcpy(&btTypeAndPower, &DataBuffer[nCurPos], sizeof(BYTE));
				nCurPos += sizeof(BYTE);
				//报文类型
				BYTE btType = 0;
				btType = (btTypeAndPower >>4) & 0x0F;
				//电池电量
				BYTE btPower = 0;
				btPower = btTypeAndPower & 0x0F;
				pCard->ranging_type = btType;
				pCard->power_state = btPower;

				//保留
				nCurPos += sizeof(BYTE);
				//加速度
				BYTE btAcceleration = 0;
				memcpy(&btAcceleration, &DataBuffer[nCurPos], sizeof(BYTE));
				nCurPos += sizeof(BYTE);
				pCard->accelerate_state = btAcceleration;

				//定位时间戳Tsp // 字序
				LONG64 lTime1 = 0;
				BYTE btTemp = 0;
				int nRangingPos = nCurPos;
				memcpy(&btTemp, &DataBuffer[nCurPos], sizeof(BYTE));
				nCurPos += sizeof(BYTE);
				DWORD dwTemp = 0;
				CFunctions::getDWord(DataBuffer, &dwTemp, nCurPos);
				nCurPos += sizeof(DWORD);
				lTime1 = btTemp;
				lTime1 = lTime1 << 32;
				lTime1 |= dwTemp;
				pCard->flying_time = lTime1;

				double dbldist = CFunctions::getDistance(lTime1);
				pCard->distance = dbldist;

				BYTE btAntenna = 0;
				memcpy(&btAntenna, &DataBuffer[nCurPos], sizeof(BYTE));
				nCurPos += sizeof(BYTE);
				btAntenna = btAntenna & 0xFF;
				pCard->antenna_id = btAntenna;

				if(CHAR_LOCATEDATAHIS_TDOA == wChr ){
					// 分站时间同步序列号 
					WORD wSyncNum = 0;
					CFunctions::getWord(DataBuffer, &wSyncNum, nCurPos);
					nCurPos += sizeof(WORD);
					// 信号强度
					WORD wStrength = 0;
					CFunctions::getWord(DataBuffer, &wStrength, nCurPos);
					nCurPos += sizeof(WORD);
				}
				break;
			}
		case CT_PERSON:
			{
				break;
			}
		default:
			{				
				//strBuf.Format(_T("无法识别的卡类型:%d\r\n"), btCardType);
				break;
			}						
		}
		store_data_card(pCard, HIS_RAW_DATA);
		delete pCard;
	}
}

void CYAServerDlg::parse_data_locate_reader_his( BYTE * DataBuffer, int nLen, int& nCurPos, int& reader_id, int& nTick, CString& strtime, unsigned short wChr)
{
	//CString strTime;
	strtime.Format(_T("%s"), COleDateTime::GetCurrentTime().Format(_T("%Y-%m-%d %H:%M:%S")));

	DWORD dwReaderID = 0;
	CFunctions::getDWord(DataBuffer, &dwReaderID, nCurPos);
	nCurPos += sizeof(DWORD);

	WORD wTickCount = 0;
	CFunctions::getWord(DataBuffer, &wTickCount, nCurPos);
	nCurPos += sizeof(WORD);
}

void CYAServerDlg::parse_data_reader_synctime(BYTE *DataBuffer, int nLen, int& nCurPos)
{
	while(nCurPos < nLen - sizeof(WORD)){
		DWORD dwReaderID = 0; // 本机分站号
		CFunctions::getDWord(DataBuffer, &dwReaderID, nCurPos);
		nCurPos += sizeof(DWORD);

		BYTE btAnt = 0; // 本机发送天线
		memcpy(&btAnt, &DataBuffer[nCurPos], sizeof(BYTE));
		nCurPos += sizeof(BYTE);

		DWORD dwRootReaderID = 0; // root分站号
		CFunctions::getDWord(DataBuffer, &dwRootReaderID, nCurPos);
		nCurPos += sizeof(DWORD);

		BYTE btRootAnt = 0; // root天线
		memcpy(&btRootAnt, &DataBuffer[nCurPos], sizeof(BYTE));
		nCurPos += sizeof(BYTE);

		WORD wSyncNum = 0; // 序列号
		CFunctions::getWord(DataBuffer, &wSyncNum, nCurPos);
		nCurPos += sizeof(WORD);

		WORD wSyncLevel = 0; // 同步等级
		CFunctions::getWord(DataBuffer, &wSyncLevel, nCurPos);
		nCurPos += sizeof(WORD);

		LONG64 lTime1 = 0, lTime2 = 0;
		BYTE btTemp = 0;
		memcpy(&btTemp, &DataBuffer[nCurPos], sizeof(BYTE));
		nCurPos += sizeof(BYTE);
		DWORD dwTemp = 0;
		CFunctions::getDWord(DataBuffer, &dwTemp, nCurPos);
		nCurPos += sizeof(DWORD);
		lTime1 = btTemp; // 本机发送时间戳
		lTime1 = lTime1 << 32;
		lTime1 |= dwTemp;

		btTemp = 0;
		dwTemp = 0;
		memcpy(&btTemp, &DataBuffer[nCurPos], sizeof(BYTE));
		nCurPos += sizeof(BYTE);
		CFunctions::getDWord(DataBuffer, &dwTemp, nCurPos);
		nCurPos += sizeof(DWORD);
		lTime2 = btTemp; // 本机接收时间戳
		lTime2 = lTime2 << 32;
		lTime2 |= dwTemp;

		CString strLog;
		strLog.Format(_T("id1:%d, id2:%d, syncnum:%d, level:%d, send:%I64u, rec:%I64u"), dwReaderID, dwRootReaderID, wSyncNum, wSyncLevel, lTime1, lTime2);
		writeErrorLog(_T("SYNC_S"), strLog, true);

		HostServer::SyncTimeMsg msg;
		msg.LocalIdCode(dwReaderID);
		msg.LocalIdCode((msg.LocalIdCode() << 8) + btAnt);
		msg.UpperIdCode(dwRootReaderID);
		msg.UpperIdCode((msg.UpperIdCode() << 8) + btRootAnt);
		msg.SyncNum(wSyncNum);
		msg.SyncLevel(wSyncLevel);
		msg.LocalStationSendTime(lTime1);
		msg.LocalStationReceiveTime(lTime2);
		syncmanager.analyzeSyncMsg(msg);

		ReaderMap::iterator it = mp_reader_list.find(dwReaderID);
		if(it != mp_reader_list.end()){
			it->second->sync_level = wSyncLevel;
		}
	}
	//CString strlog;
	//strlog.Format(_T("syncnum:%d, readerid:%I64u, upperid:%I64u, rec_time:%I64u, real_rec_time:%I64u, send_time:%I64u, time_delay:%I64u"),
	//	wSyncNum, 
	//	msg.LocalIdCode(),
	//	msg.UpperIdCode(),
	//	syncmanager._historySync[wSyncNum][msg.LocalIdCode()].ReceiveTime(),
	//	syncmanager._historySync[wSyncNum][msg.LocalIdCode()].RealReceiveTime(),
	//	syncmanager._historySync[wSyncNum][msg.LocalIdCode()].SendTime(),
	//	syncmanager._historySync[wSyncNum][msg.LocalIdCode()].TimeDelay()
	//	);
	//if(28 == dwReaderID){
	//	writeErrorLog(_T("SYNC_S28"), strlog, false);
	//}else if(27 == dwReaderID){
	//	writeErrorLog(_T("SYNC_S27"), strlog, false);
	//}else if(66 == dwReaderID){
	//	writeErrorLog(_T("SYNC_S66"), strlog, false);
	//}
}

int CYAServerDlg::init_antenna_sync()
{
	ReaderMap::iterator itReader = mp_reader_list.begin();
	// 初始化数组，将分站添加到列表，只有一个天线
	for(; itReader != mp_reader_list.end(); ++itReader){
		syncmanager.updateAnchor(itReader->second->reader_id, 1, 
			itReader->second->ant[0]->antenna_x * itReader->second->map_scale, 
			itReader->second->ant[0]->antenna_y * itReader->second->map_scale, 
			itReader->second->ant[0]->antenna_z * itReader->second->map_scale);
		//syncmanager.updateAnchor(itReader->second->reader_id, 2, itReader->second->ant[1]->antenna_x, itReader->second->ant[1]->antenna_y, itReader->second->ant[1]->antenna_z);
	}

	// 根据坐标计算分站间距离
	for (auto it = syncmanager._anchors.begin(); it != syncmanager._anchors.end(); it++)
	{
		for (auto it2 = syncmanager._anchors.begin(); it2 != syncmanager._anchors.end(); it2++)
		{
			if(it != it2)
			{
				double d = sqrt(pow((it->second.x - it2->second.x), 2)
					+ pow((it->second.y - it2->second.y), 2) 
					+ pow((it->second.z - it2->second.z), 2)) * 10000 / (2.99702547 * 15.65);
				syncmanager.updateDistance(it->first >>8, it->first & 0xFF, it2->first >> 8, it2->first & 0xFF,d);
			}
		}
	}
	return 0;
}

void CYAServerDlg::Test()
{
	ReaderPath* prp = new ReaderPath();
	/*prp->x[0] = -1;
	prp->x[1] = 1;
	prp->y[0] = 0;
	prp->y[1] = 0;

	prp->px[0] = -1;
	prp->px[1] = 1;
	prp->py[0] = 0;
	prp->py[1] = 0;

	//double dist = 0.5;
	double dist = -0.5;*/

	//2
	/*prp->x[0] = 10;
	prp->x[1] = 10;
	prp->y[0] = 2;
	prp->y[1] = 13.7;

	prp->px[0] = 10;
	prp->px[1] = 10;
	prp->py[0] = 2;
	prp->py[1] = 13.7;*/

	//3
	prp->x[0] = mp_reader_path_list_tdoa.find(27)->second.find(28)->second->x[0];
	prp->x[1] = mp_reader_path_list_tdoa.find(27)->second.find(28)->second->x[1];
	prp->y[0] = mp_reader_path_list_tdoa.find(27)->second.find(28)->second->y[0];
	prp->y[1] = mp_reader_path_list_tdoa.find(27)->second.find(28)->second->y[1];

	prp->px[0] = mp_reader_path_list_tdoa.find(27)->second.find(28)->second->px[0];
	prp->px[1] = mp_reader_path_list_tdoa.find(27)->second.find(28)->second->px[1];
	prp->py[0] = mp_reader_path_list_tdoa.find(27)->second.find(28)->second->py[0];
	prp->py[1] = mp_reader_path_list_tdoa.find(27)->second.find(28)->second->py[1];

	//double dist = 0.5;
	double dist = -0.5;

	RESULT* r = NULL;
	r = LocateAlgorithm::GetPos(prp,dist,0);

	//因为双曲线与分站之间第i条线段或者第j条线段分别有两焦点
	//或者分站之间就一条直线，有两焦点
	double xcross[2] = {0};
	double ycross[2] = {0};

	for(int j = 0; j < 2;j++){
		xcross[j] = r->x[j];
		ycross[j] = r->y[j];
	}

	double deltad[2] = {0};
	for(int j = 0; j < 2;j ++){
		double d[2] = {0};
		double dx1 = r->x[j] - prp->x[0];
		double dy1 = r->y[j] - prp->y[0];
		d[0] = sqrt(pow(dx1,2) + pow(dy1,2));

		double dx2 = r->x[j] - prp->x[1];
		double dy2 = r->y[j] - prp->y[1];
		d[1] = sqrt(pow(dx2,2) + pow(dy2,2));

		deltad[j] = d[0] - d[1];
	}

	//解的索引
	int idx = 0;
	if(dist > 0){
		for(int j = 0;j < 2;j++){
			if(deltad[j] > 0){
				idx = j;
				break;
			}
		}	
	}else{
		for(int j = 0;j < 2;j++){
			if(deltad[j] < 0){
				idx = j;
				break;
			}
		}	
	}

	bool bs = false;

	_coordinate res;
	if(!bs){
		res.x = xcross[idx];
		res.y = ycross[idx];
	}else{
		//例如当分站为B1B3,B2B3的情况下
		double tempx = xcross[idx];
		double tempy = ycross[idx];

		res.x = (tempx + res.x)/2.0;
		res.y = (tempy + res.y)/2.0;
	}
}