Merge branch 'master' of http://local.beijingyongan.com:3000/linux-dev/ya-serv

Makefile.am

@@ -3,7 +3,11 @@ noinst_PROGRAMS=client async test
 
 SRC_MONKEYCAR= monkey_car/monkeycar_area.cpp monkey_car/monkeycar_bus.cpp monkey_car/monkeycar_person.cpp
 
-SRC_MODULE_SERVICE= module_service/module_call.cpp module_service/module_meta_date_changed.cpp module_service/module_web.cpp
+SRC_MODULE_SERVICE= module_service/area_business_car_attendance.cpp module_service/area_business_card_enter_or_leave.cpp \
+					module_service/area_business_count_checker.cpp module_service/area_business_forbid.cpp \
+					module_service/area_business_person_dwell_checker.cpp module_service/area_business_post_area.cpp \
+					module_service/module_call.cpp module_service/module_meta_date_changed.cpp module_service/module_web.cpp \
+					module_service/area_business_speed_checker.cpp
 
 SRC_MAIN= ant.cpp area.cpp base64.cpp bindmorecard.cpp mine_business.cpp card_area.cpp card_base.cpp card_car.cpp \
     	  card.cpp card_message_handle.cpp cardMgr.cpp card_path.cpp card_person.cpp crc.cpp geo_hash.cpp \
@@ -15,10 +19,9 @@ SRC_MAIN_EVENT= mine_module/MineCardManager.cpp
 
 SRC_SYSTEM_BASIC= system_basic_info/SystemAnalysis.cpp
 
-CXXFLAGS=-g
 AM_SOURCES=$(SRC_MONKEYCAR) $(SRC_MODULE_SERVICE) $(SRC_MAIN) $(SRC_MAIN_EVENT) $(SRC_SYSTEM_BASIC)
 
-AM_CPPFLAGS=-Wall -pthread -m64 -g -std=c++11  -I${prefix}/include -I/usr/local/mysql/include -Iwebsocket -Iwebsocket/sio -I./db -I../dist/include -I../rapidjson/include
+AM_CPPFLAGS=-Wall -pthread -m64 -g -std=c++11  -I${prefix}/include -I/usr/local/mysql/include -Iwebsocket -Iwebsocket/sio -I./db -I../dist/include -I../rapidjson/include -Imodule_service
 
 AM_LDFLAGS=-Wall -pthread -m64 -g -std=c++11  -L${prefix}/lib  -L/usr/local/mysql/lib -L../dist/lib
 

ant.cpp

@@ -3,7 +3,7 @@
 #include <math.h>
 #include "ant.h"
 #include "db_api/CDBSingletonDefine.h"
-#include "ya_event.h"
+#include "event.h"
 template<> std::shared_ptr<sit_list> 
 single_base<sit_list, int, std::shared_ptr<site>>::m_instance=std::make_shared<sit_list>();
 int site::index()const

area_business.cpp

@@ -1,8 +1,8 @@
 
 #include <assert.h>
-
-#include "card_base.h"
 #include "area_business.h"
+
+#ifdef 0
 #include "area.h"
 #include "card.h"
 #include "ya_event.h"
@@ -127,6 +127,20 @@ struct area_business_restricted:area_business
 #endif
     }
 };
+#endif
+//#include "card_base.h"
+//#include "area.h"
+//#include "card.h"
+
+#include "area_business_car_attendance.h"
+#include "area_business_card_enter_or_leave.h"
+#include "area_business_count_checker.h"
+#include "area_business_forbid.h"
+#include "area_business_person_dwell_checker.h"
+#include "area_business_person_attendance.h"
+#include "area_business_post_area.h"
+#include "area_business_speed_checker.h"
+>>>>>>> 9972966e8ab3d9a55d0a26abd281ca082b8608ac
 
 /*
 	猴车区域
@@ -139,92 +153,6 @@ struct area_business_monkey_area:area_business
 	}
 };
 
-/*
-	车辆考勤
-*/
-struct area_business_car_attendance:area_business
-{
-	virtual int area_business_type()
-	{
-		return 6;
-	
-	}
-	//记录进入时间等信息,结束考勤,根据离开的时间和距离，判断是否记录一条新的考勤记录
-	virtual void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
-	virtual void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
-	//记录离开考勤区域信息,开始考勤
-	virtual void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
-};
-
-/*
-	人员考勤
-*/
-struct area_business_person_attendance:area_business
-{
-	virtual int area_business_type()
-	{
-		return 5;
-	
-	}
-	//记录进入时间等信息,开始考勤
-	virtual void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
-	virtual void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
-	//记录离开考勤区域信息,结束考勤
-	virtual void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
-};
-
-/*
-	判断当前区域a中的人数是否超过设定人数，超过后告警
-	区域内实时人数存储在area对象中,在当前类on_enter/on_leave中进行更新
-	整个井下的超员和某个区域的超员都使用这个代码
-*/
-struct area_business_count_checker:area_business
-{
-
-	virtual int area_business_type()
-	{
-		return 3;
-	
-	}
-	//增加计数,并进行判断
-	virtual void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
-	virtual void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
-	//减少计数
-	virtual void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
-};
-
-
-/*
-	判断当前区域a中的人卡停留时间
-	人员进入区域时间存储在area_hover对象中,在当前类on_enter/on_leave中进行更新
-	人员&车辆的代码重用，请自行设计
-*/
-struct area_business_person_dwell_checker:area_business
-{
-	virtual int area_business_type()
-	{
-		return 2;
-	}
-	//进入区域，记录进入时间
-	virtual void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
-	//判断是否超时
-	virtual void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
-	//如果有超时告警，取消超时告警
-	virtual void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
-};
-
-struct area_business_card_enter_or_leave:area_business
-{
-	virtual int area_business_type()
-	{
-		return 9;
-	}
-	//进入区域则入库操作
-	virtual void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
-	virtual void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
-	//出区域则入库
-	virtual void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
-};
 
 struct area_business_factory
 {
@@ -272,7 +200,7 @@ private:
 		regist(4,new area_business_speed_checker);
 		regist(5,new area_business_person_attendance);
 		regist(6,new area_business_car_attendance);
-		regist(7,new area_business_restricted);
+		regist(7,new area_business_forbid);
 		//regist(8,new area_business_monkey_area);
 		regist(9,new area_business_card_enter_or_leave);
 	}

area_business.h

@@ -9,14 +9,18 @@ struct business_data
 	virtual ~business_data(){}
 };
 
+struct area_hover;
+struct card_location_base;
 struct area_business
 {
-	virtual int area_business_type()=0;
+	virtual int area_business_type();
 
-	virtual void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
+	virtual void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data>&ptr){}
 	virtual void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
 	virtual void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr){}
 
+	virtual ~area_business(){}
+
 	static std::vector<area_business*> get_instance_list(int business_type);
 };
 #endif

card_person.cpp

@@ -12,7 +12,7 @@
 #include "select_tool.h"
 #include "monkey_car/monkeycar_person.h"
 #include "websocket/ws_common.h"
-#include "ya_event.h"
+#include "event.h"
 #include "mine_business.h"
 
 person::person(const std::string &type,uint32_t cardid,uint16_t needdisplay,int16_t t,int32_t deptid,int32_t level_id,uint32_t cid,int wl,const std::string &sname,const std::string &dname)

db/db_tool.cpp

@@ -66,5 +66,45 @@ namespace db_tool
 
         PushAsync(sql);
     }
+
+    void save_attendance(const std::shared_ptr<card_location_base>& card_ptr,
+                         bool is_attendance, std::chrono::system_clock::time_point& attendance_start_time)
+    {
+        char sql[LENGTH_SQL] = {0};
+
+        std::string call("add_att_staff");
+        if(card_ptr->is_vehicle())//车卡
+        {
+            call="add_att_vehicle";
+        }
+
+        auto start = attendance_start_time;
+        auto end = attendance_start_time;
+        if(!is_attendance)//考勤结束时间
+        {
+            end = std::chrono::system_clock::now();
+        }
+
+        std::string start_str = tool_time::to_str(start);
+        std::string end_str = tool_time::to_str(end);
+
+        int landmarkid = 0;
+        int landmarkdirect=0;
+        double landmarkdist=0;
+        auto area_hover_ptr = card_ptr->get_area_hover();
+        if(area_hover_ptr)
+        {
+            landmarkid = area_hover_ptr->landmark_id;
+            landmarkdirect = area_hover_ptr->landmark_dir;
+            landmarkdist = area_hover_ptr->landmark_dis;
+        }
+
+        sprintf(sql, "CALL %s(%s, %d, '%s', '%s', %d, %d, %.3f);", call.c_str(),
+               type_id_to_str(card_ptr->m_type,card_ptr->m_id).c_str(),
+                card_ptr->m_id, start_str.c_str(), end_str.c_str(),
+                landmarkid, landmarkdirect, landmarkdist);
+
+        PushAsync(sql);
+    }
 }
 

event.cpp

@@ -1,179 +1,128 @@
 #include "event.h"
+
+#include<string>
+
 #include "ant.h"
 #include "area.h"
 #include "card.h"
 #include "common_tool.h"
-struct ya_event
+#include "websocket/constdef.h"
+#include "db/db_api/CDBSingletonDefine.h"
+#include"tool_time.h"
+#include"ant.h"
+#include"db/db_tool.h"
+
+
+uint64_t ya_event::get_list_id()
 {
-private:
-    uint64_t m_ev_id;
-public:
-    ya_event(uint64_t e_id):m_cur_time(std::chrono::system_clock::now())
-    {
-        m_ev_id = e_id;
-        m_obj_id = "";
-        m_map_id = 0;
-        m_area_id = 0;
-        x = 0;
-        y = 0;
-        m_limit_value = 0;
-        m_cur_value = 0;
-        m_desc = "";
-        m_landmarkid = 0;
-        m_landmarkdirect = 0;
-        m_landmarkdist = 0;
-
-        m_status=ES_START;
-        m_is_display=true;
-		m_is_sent=false;
-    }
-    ~ya_event(){}
-public:
-    ///告警状态，开始、结束
-    EVENT_STATUS m_status;
-
-    ///告警类型
-    EVENT_TYPE m_ev_type;
-    ///告警对象类型
-    OBJECT_TYPE m_obj_type;
-    /// 告警对象编号，与告警对象类型对应，如告警对象类型为分站，此字段为分站编号
-    std::string m_obj_id;
-    ///当前时间，为告警事件的触发时间，如果状态为开始，则表示开始时间，否则为结束时间
-    std::chrono::system_clock::time_point m_cur_time;
-
-    ///告警所在地图
-    int m_map_id;
-    ///告警所在区域
-    int m_area_id;
-    ///位置
-    double x;
-    ///位置
-    double y;
-    ///告警阈值
-    double m_limit_value;
-    ///当前值
-    double m_cur_value;
-    ///描述
-    std::string m_desc;
-
-    /// 地标信息
-    int m_landmarkid;
-    /// 与地标的距离
-    double m_landmarkdist;
-    /// 所处地标的方向
-    int m_landmarkdirect;
-	//是否显示
-    bool m_is_display;
-	//是否已经发送 ture bu发送， false推送. 推送完置为true
-	bool m_is_sent;
-
-    bool is_end()
-    {
-        return ES_END == m_status;
-    }
-};
+    uint64_t car_id = tool_other::type_id_to_u64(tool_other::id64_to_type(m_obj_id), tool_other::id64_to_id(m_obj_id));
+    return  event_list::to_list_id(m_ev_type, m_obj_type,car_id);
+}
+
 
 struct Event
 {
-	OBJECT_TYPE m_oid;
-	Event(OBJECT_TYPE oid)
-		:m_oid(oid)
-	{}
-	void handle_alarm_event(EVENT_TYPE et,uint64_t id,double limit_value,double cur_value,bool f);
-	virtual std::shared_ptr<ya_event> on_message(EVENT_TYPE et,uint64_t id,bool f)=0;
-	std::shared_ptr<ya_event> create_event(uint64_t obj_id,EVENT_TYPE ev_type);
-	virtual ~Event(){}
+    OBJECT_TYPE m_oid;
+    Event(OBJECT_TYPE oid)
+        :m_oid(oid)
+    {}
+    void handle_alarm_event(EVENT_TYPE et,uint64_t id,double limit_value,double cur_value,bool f);
+    virtual std::shared_ptr<ya_event> on_message(EVENT_TYPE et,uint64_t id,bool f)=0;
+    std::shared_ptr<ya_event> create_event(std::string obj_id,EVENT_TYPE ev_type);
+    virtual ~Event(){}
 };
 struct mine_event:Event
 {
-	mine_event(OBJECT_TYPE oid)
-		:Event(oid)
-	{}
-	virtual std::shared_ptr<ya_event> on_message(EVENT_TYPE et,uint64_t id,bool f);
+    mine_event()
+        :Event(OT_MINE)
+    {}
+    virtual std::shared_ptr<ya_event> on_message(EVENT_TYPE et,uint64_t id,bool f);
 };
 struct area_event:Event
 {
-	area_event(OBJECT_TYPE oid)
-		:Event(oid)
-	{}
-	virtual std::shared_ptr<ya_event> on_message(EVENT_TYPE et,uint64_t id,bool f);
+    area_event()
+        :Event(OT_AREA)
+    {}
+    virtual std::shared_ptr<ya_event> on_message(EVENT_TYPE et,uint64_t id,bool f);
 };
 struct device_reader_event:Event
 {
-	device_reader_event(OBJECT_TYPE oid)
-		:Event(oid)
-	{}
-	virtual std::shared_ptr<ya_event> on_message(EVENT_TYPE et,uint64_t id,bool f);
+    device_reader_event()
+        :Event(OT_DEVICE_READER)
+    {}
+    virtual std::shared_ptr<ya_event> on_message(EVENT_TYPE et,uint64_t id,bool f);
 };
 struct card_event:Event
 {
-	card_event(OBJECT_TYPE oid)
-		:Event(oid)
-	{}
-	virtual std::shared_ptr<ya_event> on_message(EVENT_TYPE et,uint64_t id,bool f);
+    card_event()
+        :Event(OT_CARD)
+    {}
+    virtual std::shared_ptr<ya_event> on_message(EVENT_TYPE et,uint64_t id,bool f);
 };
 
 event_tool * event_tool::instance()
 {
-	static event_tool et;
-	return &et;
+    static event_tool et;
+    return &et;
 }
 void event_tool::make_event_object()
 {
-	m_map[OT_MINE] = std::make_shared<mine_event>();
-	m_map[OT_AREA] = std::make_shared<area_event>();
-	m_map[OT_DEVICE_READER] = std::make_shared<device_reader_event>();
-	m_map[OT_CARD] = std::make_shared<card_event>();
+    m_map[OT_MINE] = std::make_shared<mine_event>();
+    m_map[OT_AREA] = std::make_shared<area_event>();
+    m_map[OT_DEVICE_READER] = std::make_shared<device_reader_event>();
+    m_map[OT_CARD] = std::make_shared<card_event>();
 }
+
 void event_tool::handle_event(OBJECT_TYPE ot,EVENT_TYPE et,uint64_t id,double limit_value,double cur_value,bool f)
 {
-	m_map[ot]->handle_alarm_evnet(et,id,limit_value,cur_value,f);
+    m_map[ot]->handle_alarm_event(et,id,limit_value,cur_value,f);
 }
 
-std::shared_ptr<ya_event> Event::create_event(uint64_t obj_id,EVENT_TYPE ev_type);
+std::shared_ptr<ya_event> Event::create_event(std::string obj_id,EVENT_TYPE ev_type)
 {
     auto ev_ptr = std::make_shared<ya_event>(tool_time::now_to_us());
     ev_ptr->m_ev_type = ev_type;
-	ev_ptr->m_obj_type=m_oid;
+    ev_ptr->m_obj_type=m_oid;
+    ev_ptr->m_obj_id = obj_id;
     return ev_ptr;
 }
 
 void Event::handle_alarm_event(EVENT_TYPE et,uint64_t id,double limit_value,double cur_value,bool f)
 {
-	std::shared_ptr<ya_event> ev_ptr = nullptr;
-	uint64_t eid = event_list::to_list_id(et,m_oid,id);
-	auto event_ptr = event_list::instance()->get(eid);
-	if(f)
-	{
-		if(event_ptr)
-		{
-			//已经存在告警
-			event_ptr->m_cur_value = cur_value;
-			event_ptr->m_is_sent=false;
-		}
-		else
-		{
-			ev_ptr=on_message(et,id,f);
-			ev_ptr->m_cur_value=cur_value;
-			ev_ptr->m_limit_value=limit_value;
-			//保存告警信息
-			event_list::instance()->add(eid,ev_ptr);
-		}
-	}
-	else
-	{
-		if(event_ptr)		
-		{
-			//取消告警
-			event_ptr->m_cur_time = std::chrono::system_clock::now();
-			event_ptr->m_status = ES_END;
-			event_ptr->m_cur_value = cur_value;
-			event_ptr->m_is_sent=false;
-			ev_ptr=event_ptr;
-		}
-	}
-	if(ev_ptr)
-	{
+    std::shared_ptr<ya_event> ev_ptr = nullptr;
+    uint64_t eid = event_list::to_list_id(et,m_oid,id);
+    auto event_ptr = event_list::instance()->get(eid);
+    if(f)
+    {
+        if(event_ptr)
+        {
+            //已经存在告警
+            event_ptr->m_cur_value = cur_value;
+            event_ptr->m_is_sent=false;
+        }
+        else
+        {
+            ev_ptr=on_message(et,id,f);
+            ev_ptr->m_cur_value=cur_value;
+            ev_ptr->m_limit_value=limit_value;
+            //保存告警信息
+            event_list::instance()->add(eid,ev_ptr);
+        }
+    }
+    else
+    {
+        if(event_ptr && !event_ptr->is_end())
+        {
+            //取消告警
+            event_ptr->m_cur_time = std::chrono::system_clock::now();
+            event_ptr->m_status = ES_END;
+            event_ptr->m_cur_value = cur_value;
+            event_ptr->m_is_sent=false;
+            ev_ptr=event_ptr;
+        }
+    }
+    if(ev_ptr)
+    {
         char sql[LENGTH_SQL] = {0};
         std::string _time = tool_time::to_str_ex(ev_ptr->m_cur_time);
         sprintf(sql,
@@ -187,87 +136,101 @@ void Event::handle_alarm_event(EVENT_TYPE et,uint64_t id,double limit_value,doub
                 ev_ptr->m_landmarkid, ev_ptr->m_landmarkdist, ev_ptr->m_landmarkdirect);
 
         db_tool::PushAsync(sql);
-	}
+    }
 }
 
 
-virtual std::shared_ptr<ya_event> mine_event::on_message(EVENT_TYPE et,uint64_t id,bool f)
+std::shared_ptr<ya_event> mine_event::on_message(EVENT_TYPE et,uint64_t id,bool f)
 {
-	std::shared_ptr<ya_event> event_ptr=nullptr;
-	if(f)	
-	{
-		event_ptr=create_event(id,et);
-	}
-	return event_ptr;
+    std::shared_ptr<ya_event> event_ptr=nullptr;
+    if(f)
+    {
+        auto area_ptr = area_list::instance()->get(id);
+        if(!area_ptr)
+        {
+            log_error("create_event .can not find area ..%d",id);
+            return event_ptr;
+        }
+        event_ptr=create_event(std::to_string(id), et);
+        event_ptr->m_area_id = id;
+        event_ptr->m_map_id = area_ptr->mapid();
+    }
+    return event_ptr;
 }
-virtual std::shared_ptr<ya_event> area_event::on_message(EVENT_TYPE et,uint64_t id,bool f)
+
+std::shared_ptr<ya_event> area_event::on_message(EVENT_TYPE et,uint64_t id,bool f)
 {
-	std::shared_ptr<ya_event> event_ptr=nullptr;
-	if(f)	
-	{
-		auto area_ptr = area_list::instance()->get(id);
-		if(!area_ptr)
-		{
-			log_info("create_event .can not find area ..%d",id);
-			return event_ptr;
-		}
-		event_ptr=create_event(id,et);
-		event_ptr->m_obj_id = std::to_string(id);
-		event_ptr->m_area_id = id;
-		event_ptr->m_map_id = area_ptr->mapid();
-	}
-	return event_ptr;
+    std::shared_ptr<ya_event> event_ptr=nullptr;
+    if(f)
+    {
+        auto area_ptr = area_list::instance()->get(id);
+        if(!area_ptr)
+        {
+            log_error("create_event .can not find area ..%d",id);
+            return event_ptr;
+        }
+        event_ptr=create_event(std::to_string(id), et);
+        event_ptr->m_area_id = id;
+        event_ptr->m_map_id = area_ptr->mapid();
+    }
+    return event_ptr;
 }
-virtual std::shared_ptr<ya_event> device_reader_event::on_message(EVENT_TYPE et,uint64_t id,bool f)
+
+std::shared_ptr<ya_event> device_reader_event::on_message(EVENT_TYPE et,uint64_t id,bool f)
 {
-	std::shared_ptr<ya_event> event_ptr=nullptr;
-	if(f)	
-	{
-		auto site_ptr = site_list::instance()->get(id);
-		if(!site_ptr)
-		{
-			log_info("create_event.can not find site :%d",id);
-			return event_ptr;
-		}
-		event_ptr=create_event(id,et);
-		event_ptr->m_obj_id = std::to_string(id);
-		event_ptr->m_area_id =  site_ptr->m_area_id;
+    std::shared_ptr<ya_event> event_ptr=nullptr;
+    if(f)
+    {
+        auto site_ptr = sit_list::instance()->get(id);
+        if(!site_ptr)
+        {
+            log_info("create_event.can not find site :%d",id);
+            return event_ptr;
+        }
+        event_ptr=create_event(std::to_string(id),et);
+        event_ptr->m_area_id =  site_ptr->m_area_id;
         event_ptr->m_map_id = site_ptr->m_map_id;
         event_ptr->x = site_ptr->x;
         event_ptr->y = site_ptr->y;
-	}
-	return event_ptr;
+    }
+    return event_ptr;
 }
-virtual std::shared_ptr<ya_event> card_event::on_message(EVENT_TYPE et,uint64_t id,bool f)
+
+std::shared_ptr<ya_event> card_event::on_message(EVENT_TYPE et,uint64_t id,bool f)
 {
-	std::shared_ptr<ya_event> event_ptr=nullptr;
-	if(f)	
-	{
-		auto card_ptr = card_list::instance()->get(id);
-		std::string card_id = tool_other::get_string_cardid(id);
-		if(!card_ptr)
-		{
-			log_info("create_event.can not find card:%s",card_id.c_str());
-			return event_ptr;
-		}
-		event_ptr=create_event(id,et);
-		event_ptr->m_obj_id = card_id;
+    std::shared_ptr<ya_event> event_ptr=nullptr;
+    if(f)
+    {
+        auto card_ptr = card_list::instance()->get(id);
+        std::string card_id = tool_other::get_string_cardid(id);
+        if(!card_ptr)
+        {
+            log_info("create_event.can not find card:%s",card_id.c_str());
+            return event_ptr;
+        }
+        event_ptr=create_event(card_id,et);
         event_ptr->x = card_ptr->x;
         event_ptr->y = card_ptr->y;
         event_ptr->m_is_display = card_ptr->m_display;
-		const auto lm = card_ptr->getLandmark();
-		event_ptr->m_area_id = std::get<3>(lm);
-		event_ptr->m_map_id = std::get<2>(lm);
+        const auto lm = card_ptr->getLandmark();
+        event_ptr->m_area_id = std::get<3>(lm);
+        event_ptr->m_map_id = std::get<2>(lm);
         event_ptr->m_landmarkid = std::get<4>(lm);
         event_ptr->m_landmarkdist = std::get<6>(lm);
         event_ptr->m_landmarkdirect = std::get<5>(lm);
-	}
-	return event_ptr;
+    }
+    return event_ptr;
+}
+
+std::shared_ptr<ya_event> event_list::get_event_card(uint32_t card_id, int card_type, EVENT_TYPE ev_type)
+{
+    uint64_t id64 = tool_other::type_id_to_u64(card_type, card_id);
+    return base::get(to_list_id(ev_type, OT_CARD, id64));
 }
 
 void event_list::load_his_data_from_db()
 {
-	std::unordered_map<uint64_t, std::shared_ptr<ya_event>> map;
+    std::unordered_map<uint64_t, std::shared_ptr<ya_event>> map;
     const char *sql = "SELECT event_id, stat,event_type_id,obj_type_id,obj_id,map_id,area_id,\
             limit_value,cur_value,x,y, cur_time FROM his_event_data \
             WHERE event_id IN (SELECT MAX(event_id) FROM his_event_data \
@@ -346,7 +309,7 @@ void event_list::load_his_data_from_db()
             ev->x = x;
             ev->y = y;
 
-			map.insert(std::make_pair(event_id, ev));
+            map.insert(std::make_pair(event_id, ev));
         }
 
         for(auto&iter: m_map)
@@ -358,11 +321,66 @@ void event_list::load_his_data_from_db()
                      ,ev->x,ev->y
                      ,tool_time::to_str_ex(ev->m_cur_time).c_str());
         }
-		if(!map.empty())
-		  event_list::instance()->add(map);
+        if(!map.empty())
+            event_list::instance()->add(map);
     }
 }
 
+std::string event_list::evs_to_json(std::vector<std::shared_ptr<ya_event>> arr)
+{
+    rapidjson::Document doc(rapidjson::kObjectType);
+    rapidjson::Value data(rapidjson::kArrayType);
+    rapidjson::Document::AllocatorType& allocator=doc.GetAllocator();
+
+    auto it=arr.begin();
+    for(;it!=arr.end();++it)
+    {
+        if((*it)->m_is_display)
+        {
+            _ev_to_node(*it, allocator, data);
+        }
+    }
+
+    doc.AddMember(JSON_ROOT_KEY_CMD,JSON_CMD_VALUE_EVENT, allocator);
+    doc.AddMember(JSON_ROOT_KEY_VERSION,INTERFACE_VERSION, allocator);
+    doc.AddMember(JSON_ROOT_KEY_DATA,data, allocator);
+
+    rapidjson::StringBuffer sb;
+    rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(sb);
+    doc.Accept(writer);
+
+    return sb.GetString();
+}
+
+void event_list::_ev_to_node(std::shared_ptr<ya_event> ev_ptr,
+                             rapidjson::Document::AllocatorType& allocator,
+                             rapidjson::Value& out_data)
+{
+    rapidjson::Value ev(rapidjson::kObjectType);
+
+    ev.AddMember(JSON_KEY_EVENT_EVENT_ID,ev_ptr->get_id(), allocator);
+    ev.AddMember(JSON_KEY_EVENT_STATUS,ev_ptr->m_status, allocator);
+
+    ev.AddMember(JSON_KEY_EVENT_TYPE_ID,ev_ptr->m_ev_type, allocator);
+    ev.AddMember(JSON_KEY_EVENT_OBJ_TYPE_ID,ev_ptr->m_obj_type, allocator);
+
+    tool_json::add_member(ev, JSON_KEY_EVENT_OBJ_ID, ev_ptr->m_obj_id, allocator);
+    ev.AddMember(JSON_KEY_EVENT_MAP_ID,ev_ptr->m_map_id, allocator);
+    ev.AddMember(JSON_KEY_EVENT_AREA_ID,ev_ptr->m_area_id, allocator);
+    ev.AddMember(JSON_KEY_EVENT_X,ev_ptr->x, allocator);
+    ev.AddMember(JSON_KEY_EVENT_Y,ev_ptr->y, allocator);
+
+    ev.AddMember(JSON_KEY_EVENT_LIMIT_VALUE,ev_ptr->m_limit_value, allocator);
+    ev.AddMember(JSON_KEY_EVENT_CUR_VALUE,ev_ptr->m_cur_value, allocator);
+    ev.AddMember(JSON_KEY_EVENT_CUR_TIME,tool_time::to_ms(ev_ptr->m_cur_time), allocator);
+
+    ev.AddMember(JSON_KEY_EVENT_LANDMARK_ID,ev_ptr->m_landmarkid, allocator);
+    ev.AddMember(JSON_KEY_EVENT_LANDMARK_DIRECTION,ev_ptr->m_landmarkdirect, allocator);
+    ev.AddMember(JSON_KEY_EVENT_LANDMARK_DISTANCE,ev_ptr->m_landmarkdist, allocator);
+
+    out_data.PushBack(ev, allocator);
+}
+
 
 template<> std::shared_ptr<event_list>
 single_base<event_list, uint64_t, std::shared_ptr<ya_event>>::m_instance=std::make_shared<event_list>();

event.h

@@ -1,6 +1,15 @@
 #ifndef __EVENT_HPP__
 #define __EVENT_HPP__
 #include <memory>
+#include <chrono>
+#include<map>
+#include<rapidjson/document.h>
+#include<rapidjson/writer.h>
+#include<rapidjson/stringbuffer.h>
+#include<rapidjson/prettywriter.h>
+
+#include<write-copy.h>
+
 enum EVENT_STATUS
 {
     ///事件开始
@@ -27,7 +36,7 @@ enum OBJECT_TYPE
 enum EVENT_TYPE{ // 事件类型
     ET_AREA_OVER_COUNT_PERSON = 3,	// 区域人员超员
     ET_AREA_OVER_COUNT_VEHICLE = 4,	// 区域车辆超员
-	ET_READER_ERROR = 6,
+    ET_READER_ERROR = 6,
     ET_CARD_LOW_POWER_SERIOUS = 12, // 电量极低
 
     ET_CARD_AREA_OVER_TIME_PERSON = 15, // 人员区域超时
@@ -44,23 +53,101 @@ enum EVENT_TYPE{ // 事件类型
     ET_VEHICLE_NEAR_GEOFAULT=38,//靠近断层告警
 };
 
+struct ya_event
+{
+private:
+    uint64_t m_ev_id;
+public:
+    ya_event(uint64_t e_id):m_cur_time(std::chrono::system_clock::now())
+    {
+        m_ev_id = e_id;
+        m_obj_id = "";
+        m_map_id = 0;
+        m_area_id = 0;
+        x = 0;
+        y = 0;
+        m_limit_value = 0;
+        m_cur_value = 0;
+        m_desc = "";
+        m_landmarkid = 0;
+        m_landmarkdirect = 0;
+        m_landmarkdist = 0;
+
+        m_status=ES_START;
+        m_is_display=true;
+        m_is_sent=false;
+    }
+    ~ya_event(){}
+public:
+    ///告警状态，开始、结束
+    EVENT_STATUS m_status;
+
+    ///告警类型
+    EVENT_TYPE m_ev_type;
+    ///告警对象类型
+    OBJECT_TYPE m_obj_type;
+    /// 告警对象编号，与告警对象类型对应，如告警对象类型为分站，此字段为分站编号
+    std::string m_obj_id;
+    ///当前时间，为告警事件的触发时间，如果状态为开始，则表示开始时间，否则为结束时间
+    std::chrono::system_clock::time_point m_cur_time;
+
+    ///告警所在地图
+    int m_map_id;
+    ///告警所在区域
+    int m_area_id;
+    ///位置
+    double x;
+    ///位置
+    double y;
+    ///告警阈值
+    double m_limit_value;
+    ///当前值
+    double m_cur_value;
+    ///描述
+    std::string m_desc;
+
+    /// 地标信息
+    int m_landmarkid;
+    /// 与地标的距离
+    double m_landmarkdist;
+    /// 所处地标的方向
+    int m_landmarkdirect;
+    //是否显示
+    bool m_is_display;
+    //是否已经发送 ture bu发送， false推送. 推送完置为true
+    bool m_is_sent;
+
+    bool is_end()
+    {
+        return ES_END == m_status;
+    }
+
+    ///作为事件map列表的id，方便查找；
+    uint64_t get_list_id();
+
+    uint64_t get_id()
+    {
+        return m_ev_id;
+    }
+};
+
 class Event;
 struct event_tool
 {
-	template <class UnaryPredicate>
-	void handle_event(OBJECT_TYPE ot,EVENT_TYPE et,uint64_t id,double limit_value,double cur_value,Unarypredicate p)
-	{
-		handle_event(ot,et,id,limit_value,cur_value,p());
-	}
-	void handle_event(OBJECT_TYPE ot,EVENT_TYPE et,uint64_t id,double limit_value,double cur_value,bool f);
-	static event_tool * instance();
+    template <class UnaryPredicate>
+    void handle_event(OBJECT_TYPE ot,EVENT_TYPE et,uint64_t id,double limit_value,double cur_value,UnaryPredicate p)
+    {
+        handle_event(ot,et,id,limit_value,cur_value,p());
+    }
+    void handle_event(OBJECT_TYPE ot,EVENT_TYPE et,uint64_t id,double limit_value,double cur_value,bool f);
+    static event_tool * instance();
 private:
-	event_tool()
-	{
-		make_event_object();
-	}
-	void make_event_object();
-	std::map<OBJECT_TYPE,std::shared_ptr<Event>>  m_map;
+    event_tool()
+    {
+        make_event_object();
+    }
+    void make_event_object();
+    std::map<OBJECT_TYPE,std::shared_ptr<Event>>  m_map;
 };
 
 struct event_list:single_base<event_list,uint64_t,std::shared_ptr<ya_event>>
@@ -71,6 +158,18 @@ public:
         return (static_cast<uint64_t>(ev_type)<<48)|(static_cast<uint64_t>(obj_type)<<40)|obj_id;
     }
 
+    std::shared_ptr<ya_event> get_event_card(uint32_t card_id, int card_type, EVENT_TYPE ev_type);
+
+    std::shared_ptr<ya_event> get_event_area(int32_t area_id, EVENT_TYPE ev_type)
+    {
+        return base::get(to_list_id(ev_type, OT_AREA, static_cast<uint64_t>(area_id)));
+    }
+
+    std::shared_ptr<ya_event> get_event_reader(int32_t reader_id, EVENT_TYPE ev_type)
+    {
+        return base::get(to_list_id(ev_type,OT_DEVICE_READER, static_cast<uint64_t>(reader_id)));
+    }
+
     void load_his_data_from_db();
 
     ~event_list(){}
@@ -82,61 +181,11 @@ public:
         return evs_to_json(evs);
     }
 
-    static std::string evs_to_json(std::vector<std::shared_ptr<ya_event>> arr)
-    {
-        rapidjson::Document doc(rapidjson::kObjectType);
-        rapidjson::Value data(rapidjson::kArrayType);
-        rapidjson::Document::AllocatorType& allocator=doc.GetAllocator();
-
-        auto it=arr.begin();
-        for(;it!=arr.end();++it)
-        {
-            if((*it)->m_is_display)
-            {
-                ev_to_node(*it, allocator, data);
-            }
-        }
-
-        doc.AddMember(JSON_ROOT_KEY_CMD,JSON_CMD_VALUE_EVENT, allocator);
-        doc.AddMember(JSON_ROOT_KEY_VERSION,INTERFACE_VERSION, allocator);
-        doc.AddMember(JSON_ROOT_KEY_DATA,data, allocator);
-
-        rapidjson::StringBuffer sb;
-        rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(sb);
-        doc.Accept(writer);
-
-        return sb.GetString();
-    }
-
+    static std::string evs_to_json(std::vector<std::shared_ptr<ya_event>> arr);
 private:
-    static void ev_to_node(std::shared_ptr<ya_event> ev_ptr,
-                           rapidjson::Document::AllocatorType& allocator,
-                           rapidjson::Value& out_data)
-    {
-        rapidjson::Value ev(rapidjson::kObjectType);
-
-        ev.AddMember(JSON_KEY_EVENT_EVENT_ID,ev_ptr->get_id(), allocator);
-        ev.AddMember(JSON_KEY_EVENT_STATUS,ev_ptr->m_status, allocator);
-
-        ev.AddMember(JSON_KEY_EVENT_TYPE_ID,ev_ptr->m_ev_type, allocator);
-        ev.AddMember(JSON_KEY_EVENT_OBJ_TYPE_ID,ev_ptr->m_obj_type, allocator);
-
-        tool_json::add_member(ev, JSON_KEY_EVENT_OBJ_ID, ev_ptr->m_obj_id, allocator);
-        ev.AddMember(JSON_KEY_EVENT_MAP_ID,ev_ptr->m_map_id, allocator);
-        ev.AddMember(JSON_KEY_EVENT_AREA_ID,ev_ptr->m_area_id, allocator);
-        ev.AddMember(JSON_KEY_EVENT_X,ev_ptr->x, allocator);
-        ev.AddMember(JSON_KEY_EVENT_Y,ev_ptr->y, allocator);
-
-        ev.AddMember(JSON_KEY_EVENT_LIMIT_VALUE,ev_ptr->m_limit_value, allocator);
-        ev.AddMember(JSON_KEY_EVENT_CUR_VALUE,ev_ptr->m_cur_value, allocator);
-        ev.AddMember(JSON_KEY_EVENT_CUR_TIME,tool_time::to_ms(ev_ptr->m_cur_time), allocator);
-
-        ev.AddMember(JSON_KEY_EVENT_LANDMARK_ID,ev_ptr->m_landmarkid, allocator);
-        ev.AddMember(JSON_KEY_EVENT_LANDMARK_DIRECTION,ev_ptr->m_landmarkdirect, allocator);
-        ev.AddMember(JSON_KEY_EVENT_LANDMARK_DISTANCE,ev_ptr->m_landmarkdist, allocator);
-
-        out_data.PushBack(ev, allocator);
-    }
+    static void _ev_to_node(std::shared_ptr<ya_event> ev_ptr,
+                            rapidjson::Document::AllocatorType& allocator,
+                            rapidjson::Value& out_data);
 
 };
 #endif

main.cpp

@@ -12,7 +12,7 @@
 #include "landmark.h"
 #include "special_area.h"
 #include "mine.h"
-#include "ya_event.h"
+#include "event.h"
 #include"module_service/module_area.h"
 #include"module_service/module_mgr.h"
 

module_service/area_business_car_attendance.cpp

@@ -0,0 +1,45 @@
+
+#include "area.h"
+#include "card_base.h"
+
+#include "area_business_car_attendance.h"
+
+struct car_attendance_data:business_data
+{
+    car_attendance_data():m_is_attendance(false)
+      ,m_attendance_start_time(std::chrono::seconds(0))
+    {
+    }
+
+    ///考勤状态  0初始状态 1 没在考勤 2 考勤;参看ATTENDANCE_STATUS
+    bool m_is_attendance;
+    ///考勤开始时间
+    std::chrono::system_clock::time_point m_attendance_start_time;
+};
+
+area_business_car_attendance::area_business_car_attendance()
+{
+}
+
+
+//记录进入时间等信息,结束考勤,根据离开的时间和距离，判断是否记录一条新的考勤记录
+void area_business_car_attendance::on_enter(const std::shared_ptr<area_hover>&a,
+					const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data>&ptr)
+{
+
+}
+
+void area_business_car_attendance::on_hover(const std::shared_ptr<area_hover>&a,
+					const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
+{
+
+}
+
+//记录离开考勤区域信息,开始考勤
+void area_business_car_attendance::on_leave(const std::shared_ptr<area_hover>&a,
+					const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
+{
+
+}
+
+

module_service/area_business_car_attendance.h

@@ -0,0 +1,24 @@
+#ifndef AREA_BUSINESS_CAR_ATTENDANCE_H
+#define AREA_BUSINESS_CAR_ATTENDANCE_H
+
+#include"area_business.h"
+
+struct area_business_car_attendance:area_business
+{
+    area_business_car_attendance();
+
+    int area_business_type()
+    {
+        return 6;
+    }
+    //记录进入时间等信息,结束考勤,根据离开的时间和距离，判断是否记录一条新的考勤记录
+    void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data>&ptr);
+    void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr);
+    //记录离开考勤区域信息,开始考勤
+    void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr);
+};
+
+
+#endif // AREA_BUSINESS_CAR_ATTENDANCE_H
+
+

module_service/area_business_card_enter_or_leave.cpp

@@ -0,0 +1,25 @@
+#include "area.h"
+#include "card_base.h"
+
+#include "area_business_card_enter_or_leave.h"
+
+	//进入区域则入库操作
+void area_business_card_enter_or_leave::on_enter(const std::shared_ptr<area_hover>&a,
+							const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data>&ptr)
+{
+
+}
+
+void area_business_card_enter_or_leave::on_hover(const std::shared_ptr<area_hover>&a,
+							const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
+{
+
+}
+	//出区域则入库
+void area_business_card_enter_or_leave::on_leave(const std::shared_ptr<area_hover>&a,
+							const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
+{
+
+}
+
+

module_service/area_business_card_enter_or_leave.h

@@ -0,0 +1,21 @@
+#ifndef _area_business_card_enter_or_leave_hpp_
+#define _area_business_card_enter_or_leave_hpp_
+
+#include "area_business.h"
+
+struct area_business_card_enter_or_leave:area_business
+{
+	int area_business_type()
+	{
+		return 9;
+	}
+
+	//进入区域则入库操作
+	void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data>&ptr);
+	void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr);
+	//出区域则入库
+	void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr);
+};
+
+#endif
+

module_service/area_business_count_checker.cpp

@@ -0,0 +1,32 @@
+#include "area.h"
+#include "card_base.h"
+
+#include "area_business_count_checker.h"
+/*
+	判断当前区域a中的人数是否超过设定人数，超过后告警
+	区域内实时人数存储在area对象中,在当前类on_enter/on_leave中进行更新
+	整个井下的超员和某个区域的超员都使用这个代码
+*/
+	//增加计数,并进行判断
+void area_business_count_checker::on_enter(const std::shared_ptr<area_hover>&a,
+						const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data>&ptr)
+{
+
+
+}
+
+void area_business_count_checker::on_hover(const std::shared_ptr<area_hover>&a,
+						const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
+{
+
+
+}
+
+	//减少计数
+void area_business_count_checker::on_leave(const std::shared_ptr<area_hover>&a,
+						const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
+{
+
+
+}
+

module_service/area_business_count_checker.h

@@ -0,0 +1,28 @@
+#ifndef _area_business_count_checker_hpp_
+#define _area_business_count_checker_hpp_
+
+#include "area_business.h"
+
+/*
+	判断当前区域a中的人数是否超过设定人数，超过后告警
+	区域内实时人数存储在area对象中,在当前类on_enter/on_leave中进行更新
+	整个井下的超员和某个区域的超员都使用这个代码
+*/
+struct area_business_count_checker:area_business
+{
+
+	int area_business_type()
+	{
+		return 3;
+	
+	}
+	//增加计数,并进行判断
+	void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data>&ptr);
+	void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr);
+	//减少计数
+	void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr);
+};
+
+
+#endif
+

module_service/area_business_forbid.cpp

@@ -0,0 +1,34 @@
+
+#include "area.h"
+#include "card_base.h"
+
+#include "area_business_forbid.h"
+
+struct forbid_data:business_data
+{
+    forbid_data()
+    {
+    }
+};
+
+area_business_forbid::area_business_forbid()
+{
+}
+
+//记录进入时间等信息,生成告警
+void area_business_forbid::on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data>&ptr)
+{
+
+}
+
+void area_business_forbid::on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
+{
+
+}
+
+//记录退出时间等信息
+void area_business_forbid::on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
+{
+}
+
+

module_service/area_business_forbid.h

@@ -0,0 +1,23 @@
+#ifndef AREA_BUSINESS_FORBID_H
+#define AREA_BUSINESS_FORBID_H
+
+#include"area_business.h"
+
+struct area_business_forbid:area_business
+{
+    area_business_forbid();
+
+    int area_business_type()
+    {
+        return 7;
+    }
+    //记录进入时间等信息,生成告警
+    void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data>&ptr);
+    void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr);
+    //记录退出时间等信息
+    void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr);
+};
+
+#endif // AREA_BUSINESS_FORBID_H
+
+

module_service/area_business_person_attendance.cpp

@@ -0,0 +1,32 @@
+
+#include "area.h"
+#include "card_base.h"
+
+#include "area_business_person_attendance.h"
+
+area_business_person_attendance::area_business_person_attendance()
+{
+}
+
+
+//记录进入时间等信息,结束考勤,根据离开的时间和距离，判断是否记录一条新的考勤记录
+void area_business_person_attendance::on_enter(const std::shared_ptr<area_hover>&a,
+					const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data>&ptr)
+{
+
+}
+
+void area_business_person_attendance::on_hover(const std::shared_ptr<area_hover>&a,
+					const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
+{
+
+}
+
+//记录离开考勤区域信息,开始考勤
+void area_business_person_attendance::on_leave(const std::shared_ptr<area_hover>&a,
+					const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
+{
+
+}
+
+

module_service/area_business_person_attendance.h

@@ -0,0 +1,27 @@
+#ifndef _area_business_person_attendance_hpp_
+#define _area_business_person_attendance_hpp_
+
+#include"area_business.h"
+
+struct area_business_person_attendance:area_business
+{
+    area_business_person_attendance();
+
+    int area_business_type()
+    {
+        return 5;
+    }
+
+    //记录进入时间等信息,开始考勤
+    void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data>&ptr);
+
+    void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr);
+
+    //记录离开考勤区域信息,结束考勤
+    void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr);
+};
+
+
+#endif // AREA_BUSINESS_CAR_ATTENDANCE_H
+
+

module_service/area_business_person_dwell_checker.cpp

@@ -0,0 +1,38 @@
+
+#include "area.h"
+#include "card_base.h"
+
+#include "area_business_person_dwell_checker.h"
+/*
+	判断当前区域a中的人卡停留时间
+	人员进入区域时间存储在area_hover对象中,在当前类on_enter/on_leave中进行更新
+	人员&车辆的代码重用，请自行设计
+*/
+
+
+//进入区域，记录进入时间
+void area_business_person_dwell_checker::on_enter(const std::shared_ptr<area_hover>&a,
+							const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data>&ptr)
+{
+
+
+}
+
+
+//判断是否超时
+void area_business_person_dwell_checker::on_hover(const std::shared_ptr<area_hover>&a,
+							const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
+{
+
+
+}
+
+
+//如果有超时告警，取消超时告警
+void area_business_person_dwell_checker::on_leave(const std::shared_ptr<area_hover>&a,
+							const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
+{
+
+
+}
+

module_service/area_business_person_dwell_checker.h

@@ -0,0 +1,27 @@
+#ifndef _area_business_person_dwell_checker_hpp_
+#define _area_business_person_dwell_checker_hpp_
+
+#include"area_business.h"
+
+/*
+	判断当前区域a中的人卡停留时间
+	人员进入区域时间存储在area_hover对象中,在当前类on_enter/on_leave中进行更新
+	人员&车辆的代码重用，请自行设计
+*/
+struct area_business_person_dwell_checker:area_business
+{
+	int area_business_type()
+	{
+		return 2;
+	}
+	//进入区域，记录进入时间
+	void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data>&ptr);
+	//判断是否超时
+	void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr);
+	//如果有超时告警，取消超时告警
+	void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr);
+};
+
+
+#endif
+

module_service/area_business_post_area.cpp

@@ -0,0 +1,30 @@
+
+#include "area.h"
+#include "card_base.h"
+
+#include "area_business_post_area.h"
+/*
+	确定推送人员信息时的区域，每一个明确需要推送的区域，都要推送
+*/
+
+//将推送区域信息加入人员数据
+void area_business_post_area::on_enter(const std::shared_ptr<area_hover>&a,
+						const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data>&ptr)
+{
+
+}
+
+void area_business_post_area::on_hover(const std::shared_ptr<area_hover>&a, \
+						const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
+{
+
+}
+
+//从人员数据中清除区域信息
+void area_business_post_area::on_leave(const std::shared_ptr<area_hover>&a,
+						const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
+{
+
+}
+
+

module_service/area_business_post_area.h

@@ -0,0 +1,23 @@
+#ifndef _area_business_post_area_hpp_
+#define _area_business_post_area_hpp_
+
+#include"area_business.h"
+
+/*
+	确定推送人员信息时的区域，每一个明确需要推送的区域，都要推送
+*/
+struct area_business_post_area:area_business
+{
+	int area_business_type()
+	{
+		return 1;
+	}
+	//将推送区域信息加入人员数据
+	void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data>&ptr);
+	void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr);
+	//从人员数据中清除区域信息
+	void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr);
+};
+
+#endif
+

module_service/area_business_speed_checker.cpp

@@ -0,0 +1,35 @@
+#include "area_business_speed_checker.h"
+
+struct over_speed_data:business_data
+{
+    over_speed_data()
+    {
+        m_over_speed_count=0;
+        m_normal_speed_count=0;
+        m_limit_speed=0;
+    }
+
+    int m_over_speed_count;
+    int m_normal_speed_count;
+    double m_limit_speed;
+};
+
+area_business_speed_checker::area_business_speed_checker()
+{
+}
+
+void area_business_speed_checker::on_enter(const std::shared_ptr<area_hover>&a,
+					const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data>&ptr)
+{
+}
+
+void area_business_speed_checker::on_hover(const std::shared_ptr<area_hover>&a,
+					const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
+{
+}
+
+void area_business_speed_checker::on_leave(const std::shared_ptr<area_hover>&a,
+					const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr)
+{
+}
+

module_service/area_business_speed_checker.h

@@ -0,0 +1,20 @@
+#ifndef AREA_BUSINESS_SPEED_CHECKER_H
+#define AREA_BUSINESS_SPEED_CHECKER_H
+
+#include"area_business.h"
+
+struct area_business_speed_checker:area_business
+{
+    area_business_speed_checker();
+
+    int area_business_type()
+    {
+        return 4;
+    }
+
+    void on_enter(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data>&ptr);
+    void on_hover(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr);
+    void on_leave(const std::shared_ptr<area_hover>&a,const std::shared_ptr<card_location_base>&c,std::shared_ptr<business_data> ptr);
+};
+
+#endif // AREA_BUSINESS_SPEED_CHECKER_H

module_service/module_call_help.cpp

@@ -1,6 +1,6 @@
 #include"module_call_help.h"
 
-#include"ya_event.h"
+#include"event.h"
 #include"common_tool.h"
 #include"websocket/constdef.h"
 #include"log.h"

module_service/module_over_speed_vehicle.cpp

@@ -1,6 +1,6 @@
 #include "module_over_speed_vehicle.h"
 
-#include "ya_event.h"
+#include "event.h"
 #include"log.h"
 #include"db/db_api/CDBSingletonDefine.h"
 #include"mine.h"

module_service/module_web.h

@@ -14,7 +14,7 @@
 #include "rapidjson/document.h"
 
 #include"config_file.h"
-#include"ya_event.h"
+#include"event.h"
 #include"module_singleton_base.h"
 #include"module_i_thread.h"
 #include "websocket/wsClientMgr.h"

ya_event.cpp

@@ -1,108 +0,0 @@
-#include "ya_event.h"
-
-
-uint64_t ya_event::get_list_id()
-{
-    return event_list::to_list_id(m_ev_type, m_obj_type,
-           tool_other::id64_to_type(m_obj_id), tool_other::id64_to_id(m_obj_id));
-}
-
-void event_list::load_his_data_from_db()
-{
-    const char *sql = "SELECT event_id, stat,event_type_id,obj_type_id,obj_id,map_id,area_id,\
-            limit_value,cur_value,x,y, cur_time FROM his_event_data \
-            WHERE event_id IN (SELECT MAX(event_id) FROM his_event_data \
-                               WHERE cur_time > (CASE obj_type_id \
-                                                 WHEN 1 THEN DATE_SUB(NOW(),INTERVAL 2 DAY) \
-                                                 WHEN 2 THEN DATE_SUB(NOW(),INTERVAL 2 DAY)\
-                                                 WHEN 4 THEN DATE_SUB(NOW(),INTERVAL 1 MONTH)\
-                                                 WHEN 9 THEN DATE_SUB(NOW(),INTERVAL 2 DAY) \
-                                                 WHEN 10 THEN DATE_SUB(NOW(),INTERVAL 2 DAY) \
-                                                 END) \
-                               AND cur_time < NOW()\
-                               GROUP BY event_type_id, obj_id) \
-            AND  event_id NOT IN ( SELECT event_id FROM (SELECT * FROM his_event_data WHERE  stat=100) s);";
-    std::string Error;
-    YADB::CDBResultSet DBRes;
-    sDBConnPool.Query(sql,DBRes,Error);
-    if(!Error.empty())
-        log_error("初始化事件列表 Error,%s",Error.c_str());
-    uint64_t nCount = DBRes.GetRecordCount( Error );
-    if (nCount > 0)
-    {
-        log_info( "load_his_data_from_db. The record count=%ld\n", nCount );
-
-        while ( DBRes.GetNextRecod(Error) )
-        {
-            long long event_id  = 0;
-            DBRes.GetField( "event_id",event_id, Error );
-
-            int event_type_id  = 0;
-            DBRes.GetField( "event_type_id",event_type_id, Error );
-
-            int obj_type_id  = 0;
-            DBRes.GetField( "obj_type_id",obj_type_id, Error );
-
-            std::string obj_id  = "";
-            DBRes.GetField( "obj_id",obj_id, Error );
-
-            int map_id  = 0;
-            DBRes.GetField( "map_id",map_id, Error );
-
-            int area_id  = 0;
-            DBRes.GetField( "area_id",area_id, Error );
-
-            double limit_value = 0;
-            DBRes.GetField( "limit_value",limit_value, Error );
-
-            double cur_value = 0;
-            DBRes.GetField( "cur_value",cur_value, Error );
-
-            double x = 0;
-            DBRes.GetField( "x",x, Error );
-
-            double y = 0;
-            DBRes.GetField( "y",y, Error );
-
-            std::string cur_time  = "";
-            DBRes.GetField( "cur_time",cur_time, Error );
-
-            int stat  = 0;
-            DBRes.GetField( "stat",stat, Error );
-
-
-            std::shared_ptr<ya_event> ev = std::make_shared<ya_event>(event_id);
-            ev->m_status = static_cast<EVENT_STATUS>(stat);
-            ev->m_ev_type = static_cast<EVENT_TYPE>(event_type_id);
-
-            ev->m_obj_type = static_cast<OBJECT_TYPE>(obj_type_id);
-            ev->m_obj_id = tool_other::to13str(obj_id);
-            ev->m_cur_time = tool_time::to_time_ex(cur_time);
-
-            ev->m_cur_value = cur_value;
-            ev->m_limit_value = limit_value;
-
-            ev->m_map_id = map_id;
-            ev->m_area_id = area_id;
-            ev->x = x;
-            ev->y = y;
-
-            m_map.insert(std::make_pair(ev->get_list_id(), ev));
-        }
-
-        for(auto&iter: m_map)
-        {
-            auto ev = iter.second;
-            log_info("event list %lld,%d,%d,%d,%s,%d,%d,%f,%f,%f,%f,%s"
-                     , ev->get_id(),ev->m_status,ev->m_ev_type,ev->m_obj_type,ev->m_obj_id.c_str()
-                     ,ev->m_map_id,ev->m_area_id,ev->m_limit_value,ev->m_cur_value
-                     ,ev->x,ev->y
-                     ,tool_time::to_str_ex(ev->m_cur_time).c_str());
-        }
-    }
-}
-
-template<> std::shared_ptr<event_list>
-single_base<event_list, uint64_t, std::shared_ptr<ya_event>>::m_instance=std::make_shared<event_list>();
-
-

ya_event.h

@@ -1,340 +0,0 @@
-#ifndef YA_EVENT_H
-#define YA_EVENT_H
-
-/**
- * @brief 告警事件类型
- * @author 戴月腾
- * @date 2018-09-24
- */
-
-#include<map>
-#include<chrono>
-#include<memory>
-#include"write-copy.h"
-#include"log.h"
-#include "db_api/CDBSingletonDefine.h"
-#include"card.h"
-#include"common_tool.h"
-#include "tool_time.h"
-#include "db_tool.h"
-#include <area.h>
-#include "ant.h"
-
-/**
- * @brief 事件状态
- */
-enum EVENT_STATUS
-{
-    ///事件开始
-    ES_START = 0,
-    ///呼救已处理状态
-    ES_DEAL_HELP = 1,
-    ///事件结束
-    ES_END = 100
-};
-
-enum EVENT_TYPE{ // 事件类型
-    ET_UNKNOWN = 0,
-	ET_OVER_COUNT_PERSON = 1, // 井下人员超员pit_module/CPicardmanager
-	ET_OVER_COUNT_VEHICLE = 2,    // 井下车辆超员pit_module/CPicardmanager
-
-    ET_AREA_OVER_COUNT_PERSON = 3,	// 区域人员超员
-    ET_AREA_OVER_COUNT_VEHICLE = 4,	// 区域车辆超员
-	ET_READER_ERROR = 6,
-    ET_CARD_LOW_POWER_SERIOUS = 12, // 电量极低
-
-    ET_CARD_OVER_TIME_PERSON = 13, // 人员井下超时pit_module/CPicardmanager
-	ET_CARD_OVER_TIME_VEHICLE = 14, // 车辆井下超时pit_module/CPicardmanager
-
-    ET_CARD_AREA_OVER_TIME_PERSON = 15, // 人员区域超时
-    ET_CARD_AREA_OVER_TIME_VEHICLE = 16, // 车辆区域超时
-    ET_CARD_AREA_LIMIT_PERSON = 17, // 人员进入限制区域
-    ET_CARD_AREA_LIMIT_VEHICLE = 18, // 车辆进入限制区域
-    ET_CARD_AREA_FORBIDDEN_PERSON = 19,  // 人员进入禁止区域
-    ET_CARD_AREA_FORBIDDEN_VEHICLE = 20, // 车辆进入禁止区域
-    ET_CARD_OVER_SPEED = 21, // 车辆超速
-    ET_CARD_HELP = 24, // 人员呼救
-
-    ET_READER_POWER_BY_BATTERY=33,		//分站电池：1为电池供电，0为交流电供电，当电池供电需要告警
-
-    CARD_EVENT_COUNT_MAX,
-};
-
-/**
- * @brief 对象类型
- */
-enum OBJECT_TYPE
-{
-    ///矿井
-    OT_MINE = 1,
-    ///区域
-    OT_AREA = 2,
-    ///分站
-    OT_DEVICE_READER = 4,
-    ///标识卡，包括人员、车辆、自组网等
-    OT_CARD = 9,
-};
-
-/**
- * @brief 告警事件
- */
-struct ya_event
-{
-private:
-    uint64_t m_ev_id;
-public:
-    ya_event(uint64_t e_id):m_cur_time(std::chrono::system_clock::now())
-    {
-        m_ev_id = e_id;
-
-        m_obj_id = "";
-        m_map_id = 0;
-        m_area_id = 0;
-        x = 0;
-        y = 0;
-        m_limit_value = 0;
-        m_cur_value = 0;
-        m_desc = "";
-        m_landmarkid = 0;
-        m_landmarkdirect = 0;
-        m_landmarkdist = 0;
-
-        m_status=ES_START;
-        m_is_display=true;
-    }
-    ~ya_event(){}
-public:
-    ///告警状态，开始、结束
-    EVENT_STATUS m_status;
-
-    ///告警类型
-    EVENT_TYPE m_ev_type;
-    ///告警对象类型
-    OBJECT_TYPE m_obj_type;
-    /// 告警对象编号，与告警对象类型对应，如告警对象类型为分站，此字段为分站编号
-    std::string m_obj_id;
-    ///当前时间，为告警事件的触发时间，如果状态为开始，则表示开始时间，否则为结束时间
-    std::chrono::system_clock::time_point m_cur_time;
-
-    ///告警所在地图
-    int m_map_id;
-    ///告警所在区域
-    int m_area_id;
-    ///位置
-    double x;
-    ///位置
-    double y;
-    ///告警阈值
-    double m_limit_value;
-    ///当前值
-    double m_cur_value;
-    ///描述
-    std::string m_desc;
-
-    /// 地标信息
-    int m_landmarkid;
-    /// 与地标的距离
-    double m_landmarkdist;
-    /// 所处地标的方向
-    int m_landmarkdirect;
-
-    bool m_is_display;
-
-    bool is_end()
-    {
-        return ES_END == m_status;
-    }
-
-    ///作为事件map列表的id，方便查找；(obj_type<<32| obj_id)
-    uint64_t get_list_id();
-
-    uint64_t get_id(){return m_ev_id;}
-};
-typedef std::shared_ptr<ya_event> event_ptr;
-typedef std::map<uint64_t, std::shared_ptr<ya_event>> event_map;
-typedef std::shared_ptr<event_map> event_map_ptr;
-
-
-struct event_list:single_base<event_list,uint64_t,std::shared_ptr<ya_event>>
-{
-public:
-    ///作为事件map列表的id，方便查找；(ev_type<<48 | obj_type<<40 |  obj_id_type<<32 | obj_id)
-    static uint64_t to_list_id(EVENT_TYPE ev_type, OBJECT_TYPE obj_type, int obj_id_type, uint32_t obj_id)
-    {
-        return (static_cast<uint64_t>(ev_type)<<48)|(static_cast<uint64_t>(obj_type)<<40)
-                |(static_cast<uint64_t>(obj_id_type)<<32)|static_cast<uint64_t>(obj_id);
-    }
-    ///创建井下警告
-    static event_ptr create_event_mine(int objid, EVENT_TYPE ev_type)
-    {
-        return create_event(OT_MINE, objid, 0, ev_type);
-    } 
-    ///创建区域警告
-    static event_ptr create_event_area(int area_id, EVENT_TYPE ev_type)
-    {
-        return create_event(OT_AREA, area_id, 0, ev_type);
-    }
-
-    static event_ptr create_event_reader(int reader_id, EVENT_TYPE ev_type)
-    {
-        return create_event(OT_DEVICE_READER, reader_id, 0, ev_type);
-    }
-    ///创建与卡有关的警告，需要卡类型
-    static event_ptr create_event_card(uint32_t card_id, int32_t card_type, EVENT_TYPE ev_type)
-    {
-        return create_event(OT_CARD, static_cast<int32_t>(card_id), card_type, ev_type);
-    }
-
-    static void copy_event(const std::shared_ptr<card_location_base> card_ptr, event_ptr ev_ptr)
-    {
-        ev_ptr->x = card_ptr->x;
-        ev_ptr->y = card_ptr->y;
-        ev_ptr->m_cur_time = std::chrono::system_clock::now();
-        ev_ptr->m_is_display = card_ptr->m_display;
-
-        auto hover = card_ptr->get_area_hover();
-        if(nullptr!=hover)
-        {
-            ev_ptr->m_area_id =  hover->m_area->id();
-            ev_ptr->m_map_id = hover->m_area->mapid();
-
-            ev_ptr->m_landmarkid = hover->landmark_dir;
-            ev_ptr->m_landmarkdist = hover->landmark_dis;
-            ev_ptr->m_landmarkdirect = hover->landmark_dir;
-        }
-    }
-
-    static void copy_event(const std::shared_ptr<area> area_ptr, event_ptr ev_ptr)
-    {
-        ev_ptr->m_cur_time = std::chrono::system_clock::now();
-        ev_ptr->m_is_display = true;
-
-        ev_ptr->m_area_id =  area_ptr->id();
-        ev_ptr->m_map_id = area_ptr->mapid();
-    }
-    static void copy_event(const std::shared_ptr<site> site_ptr, event_ptr ev_ptr)
-    {
-        ev_ptr->m_cur_time = std::chrono::system_clock::now();
-        ev_ptr->m_is_display = true;
-
-        ev_ptr->m_area_id =  site_ptr->m_area_id;
-        ev_ptr->m_map_id = site_ptr->m_map_id;
-        ev_ptr->x = site_ptr->x;
-        ev_ptr->y = site_ptr->y;
-    }
-
-
-    std::shared_ptr<ya_event> get_event_card(uint32_t card_id, int card_type, EVENT_TYPE ev_type)
-    {
-        return base::get(to_list_id(ev_type, OT_CARD, card_type, card_id));
-    }
-
-    std::shared_ptr<ya_event> get_event_area(int32_t area_id, EVENT_TYPE ev_type)
-    {
-        return base::get(to_list_id(ev_type, OT_AREA, 0, static_cast<uint32_t>(area_id)));
-    }
-
-    std::shared_ptr<ya_event> get_event_reader(int32_t reader_id, EVENT_TYPE ev_type)
-    {
-        return base::get(to_list_id(ev_type,OT_DEVICE_READER, 0, static_cast<uint32_t>(reader_id)));
-    }
-    void load_his_data_from_db();
-
-    static void save_event(const event_ptr ev_ptr)
-    {
-        char sql[LENGTH_SQL] = {'\0'};
-
-        std::string _time = tool_time::to_str_ex(ev_ptr->m_cur_time);
-
-        sprintf(sql,
-                "INSERT IGNORE INTO his_event_data(event_id, stat, event_type_id, obj_type_id, obj_id, \
-                map_id, area_id, limit_value, cur_value, x, y, cur_time, description, \
-                landmark_id, landmark_dist,direction_mapper_id )\
-                VALUES(%ld, %d, %d, %d, %s, %d, %d, %.2f, %.2f, %f, %f, '%s', '%s', %d, %10.3f, %d);",
-        ev_ptr->get_id(), ev_ptr->m_status, ev_ptr->m_ev_type, ev_ptr->m_obj_type, ev_ptr->m_obj_id.c_str(),
-                ev_ptr->m_map_id, ev_ptr->m_area_id, ev_ptr->m_limit_value, ev_ptr->m_cur_value, ev_ptr->x, ev_ptr->y,
-                _time.c_str(), ev_ptr->m_desc.c_str(),
-                ev_ptr->m_landmarkid, ev_ptr->m_landmarkdist, ev_ptr->m_landmarkdirect);
-
-        db_tool::PushAsync(sql);
-    }
-
-    ~event_list(){}
-
-    static std::string ev_to_json(std::shared_ptr<ya_event> ev_ptr)
-    {
-        std::vector<std::shared_ptr<ya_event>> evs;
-        evs.push_back(ev_ptr);
-        return evs_to_json(evs);
-    }
-
-    static std::string evs_to_json(std::vector<std::shared_ptr<ya_event>> arr)
-    {
-        rapidjson::Document doc(rapidjson::kObjectType);
-        rapidjson::Value data(rapidjson::kArrayType);
-        rapidjson::Document::AllocatorType& allocator=doc.GetAllocator();
-
-        auto it=arr.begin();
-        for(;it!=arr.end();++it)
-        {
-            if((*it)->m_is_display)
-            {
-                ev_to_node(*it, allocator, data);
-            }
-        }
-
-        doc.AddMember(JSON_ROOT_KEY_CMD,JSON_CMD_VALUE_EVENT, allocator);
-        doc.AddMember(JSON_ROOT_KEY_VERSION,INTERFACE_VERSION, allocator);
-        doc.AddMember(JSON_ROOT_KEY_DATA,data, allocator);
-
-        rapidjson::StringBuffer sb;
-        rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(sb);
-        doc.Accept(writer);
-
-        return sb.GetString();
-    }
-
-private:
-    static void ev_to_node(std::shared_ptr<ya_event> ev_ptr,
-                           rapidjson::Document::AllocatorType& allocator,
-                           rapidjson::Value& out_data)
-    {
-        rapidjson::Value ev(rapidjson::kObjectType);
-
-        ev.AddMember(JSON_KEY_EVENT_EVENT_ID,ev_ptr->get_id(), allocator);
-        ev.AddMember(JSON_KEY_EVENT_STATUS,ev_ptr->m_status, allocator);
-
-        ev.AddMember(JSON_KEY_EVENT_TYPE_ID,ev_ptr->m_ev_type, allocator);
-        ev.AddMember(JSON_KEY_EVENT_OBJ_TYPE_ID,ev_ptr->m_obj_type, allocator);
-
-        tool_json::add_member(ev, JSON_KEY_EVENT_OBJ_ID, ev_ptr->m_obj_id, allocator);
-        ev.AddMember(JSON_KEY_EVENT_MAP_ID,ev_ptr->m_map_id, allocator);
-        ev.AddMember(JSON_KEY_EVENT_AREA_ID,ev_ptr->m_area_id, allocator);
-        ev.AddMember(JSON_KEY_EVENT_X,ev_ptr->x, allocator);
-        ev.AddMember(JSON_KEY_EVENT_Y,ev_ptr->y, allocator);
-
-        ev.AddMember(JSON_KEY_EVENT_LIMIT_VALUE,ev_ptr->m_limit_value, allocator);
-        ev.AddMember(JSON_KEY_EVENT_CUR_VALUE,ev_ptr->m_cur_value, allocator);
-        ev.AddMember(JSON_KEY_EVENT_CUR_TIME,tool_time::to_ms(ev_ptr->m_cur_time), allocator);
-
-        ev.AddMember(JSON_KEY_EVENT_LANDMARK_ID,ev_ptr->m_landmarkid, allocator);
-        ev.AddMember(JSON_KEY_EVENT_LANDMARK_DIRECTION,ev_ptr->m_landmarkdirect, allocator);
-        ev.AddMember(JSON_KEY_EVENT_LANDMARK_DISTANCE,ev_ptr->m_landmarkdist, allocator);
-
-        out_data.PushBack(ev, allocator);
-    }
-
-private:
-    static event_ptr create_event(OBJECT_TYPE obj_type, int obj_id, int type, EVENT_TYPE ev_type)
-    {
-        auto ev_ptr = std::make_shared<ya_event>(tool_time::now_to_us());
-
-        ev_ptr->m_ev_type = ev_type;
-        ev_ptr->m_obj_type = obj_type;
-        ev_ptr->m_obj_id = tool_other::type_id_to_str(type, obj_id);
-
-        return ev_ptr;
-    }
-};
-
-#endif // YA_EVENT_H