server/card.cpp

#include <memory>
#include <log.h>
#include <zloop.h>
#include "select_tool.h"
#include "loc_tool.h"

#include <area.h>
#include <site_area.h>

#include <card.h>
#include "config_file.h"
#include "db_api/CDBConnPool.h"
#include "websocket/wsTimerThread.h"
#include "websocket/wsClientMgr.h"
#include "timestamp.h"
#include "monkey_car/monkeycar_area.h"
#include "monkey_car/monkeycar_person.h"
#include "special_area.h"
#include "cardMgr.h"
#include "ant.h"
#include "mine.h"
#include "module_service/module_mgr.h"
#include "visit.h"
#include "his_location.h"
#include "three_rates.h"

extern config_file config;
//一张卡一个ct的所有不同天线的信息
struct one_ct_message_handle
{
	static loc_tool_main m_loc_tool;
	ev::timer m_min_timer,m_max_timer;
    //loc_message.
	std::vector<loc_message> m_msg_list;
	card_location_base*m_card;
	const algo_config*m_ac=nullptr;
	int  m_ct;
	bool m_min_timeout=false;
    ev::dynamic_loop * m_loop = nullptr;
	one_ct_message_handle(card_location_base*card)
	{
		m_card=card;
		m_ct=-1;
	}

	void reset()
	{
		m_ct=-1;
		m_min_timeout=false;
		m_msg_list.clear();
	}

	void on_min_timer()
	{
		m_min_timer.stop();

		if((int)m_msg_list.size()>=m_ac->best_msg_cnt)
		{
			m_max_timer.stop();
			calc_location();
            return;
		}
		m_min_timeout=true;
	}

	void on_max_timer()
	{
		m_max_timer.stop();
		calc_location();
	}
    void set(ev::dynamic_loop * loop)
    {
        m_loop = loop;

        m_min_timer.set(*m_loop);
	    m_min_timer.set<one_ct_message_handle,&one_ct_message_handle::on_min_timer>(this);
	    m_max_timer.set(*m_loop);
	    m_max_timer.set<one_ct_message_handle,&one_ct_message_handle::on_max_timer>(this);
    }
	void on_message(ev::dynamic_loop *loop,const message_locinfo&loc)
	{
        if(m_loop == nullptr && loop!=nullptr)
            set(loop);
        else if(loop == nullptr)
          return;
   		if(!m_msg_list.empty()&& m_ct!=loc.m_card_ct)
		{
			m_msg_list.clear();
		}
		auto sitPtr = sit_list::instance()->get(loc.m_site_id);
		if(sitPtr==nullptr)
		{
			log_warn("分站信息缺失,SitId:%d",loc.m_site_id);
			return;
		}
		const site &s=*(sit_list::instance()->get(loc.m_site_id));
		if(m_msg_list.empty())
		{
			m_ct=loc.m_card_ct;
			m_ac=&s.config();
			m_min_timeout=false;
            //这里构造loc_message 保存数据
			m_msg_list.push_back(loc_message(s,loc.m_tof,loc.m_time_stamp,loc.m_card_id,
							loc.m_card_ct,loc.m_card_type,loc.m_ant_id,loc.m_rav,loc.m_acc,
							loc.m_sync_ct,loc.m_rssi));

			//启动本CT的最小、最大两个定时器
			m_min_timer.start(m_ac->min_wait_time);
			m_max_timer.start(m_ac->min_wait_time);
			return;
		}

		m_msg_list.push_back(loc_message(s,loc.m_tof,loc.m_time_stamp,loc.m_card_id,
						loc.m_card_ct,loc.m_card_type,loc.m_ant_id,loc.m_rav,loc.m_acc,
						loc.m_sync_ct,loc.m_rssi));

		if(m_min_timeout && (int)m_msg_list.size()>=m_ac->best_msg_cnt)
		{
			calc_location();
			m_max_timer.stop();
		}
	}

    void calc_location()
	{
        auto v = m_msg_list;

		std::vector<point> rc=std::move(m_loc_tool.calc_location(v));
        
		if(!rc.empty()) m_card->on_location(std::move(rc),v);

		reset();
	}
};
struct card_message_handle
{
	card_location_base*m_card;
	std::array<one_ct_message_handle*,16> m_ct_list;

	card_message_handle(card_location_base*card)
	{
		m_card=card;

		for(size_t i=0;i<m_ct_list.size();i++)
		{
			m_ct_list[i]=new one_ct_message_handle(card);
		}
	}

	~card_message_handle()
	{
		for(auto&it:m_ct_list)
		{
			delete it;
		}
	}

	void on_message(zloop<task*> * loop,const message_locinfo&loc,bool is_history)
	{
		if(is_history)
		{
			log_warn("%s","当前代码没有处理历史消息记录。");
			return;
		}
		//
        m_card->site_hover(loc.m_site_id);

        if(loc.m_batty_status == 2)
        {
            m_card->do_status(STATUS_POWER_LOWER_SERIOUS);
        }
        else
        {
            m_card->do_status(STATUS_POWER_NOMARL);
        }

        if(loc.m_callinfo & 0x80)
        {
            m_card->do_status(STATUS_HELP);
        }
        if((loc.m_callinfo & 0x01) || (loc.m_callinfo & 0x02))
        {
            m_card->do_status(STATUS_CALL);
        }

		m_ct_list[loc.m_card_ct&(m_ct_list.size()-1)]->on_message(loop,loc);
	}
};

struct card_area
{
	card_area()
	{
		m_site_area.reset(new site_area_hover);
        m_area_tool.reset(new area_tool);
        m_mine_tool.reset(new mine_tool);
	}
	std::shared_ptr<site_area_hover> m_site_area=nullptr;
	std::shared_ptr<area_tool> m_area_tool=nullptr;
    std::shared_ptr<mine_tool> m_mine_tool=nullptr;
};

struct person:card_location_base, card_area
{
	std::weak_ptr<monkey_person> m_monkeyPerson;
	int m_workLine=0;
	person(std::string type,uint32_t cardid,uint16_t needdisplay,int16_t t,int32_t deptid,int32_t level_id,uint32_t cid,int wl)
        :card_location_base(type,cardid,needdisplay,t,deptid,level_id,cid)
		 ,m_workLine(wl)
	{
        m_message_handle.reset(new card_message_handle(this));
		m_his_location_card.reset(new location_staff(m_id,m_type));
	}

	void on_message(zloop<task*> * loop,const message_locinfo&loc,bool is_history)
	{
		m_message_handle->on_message(loop,loc,is_history);
	}

    void clear()
    {
        m_site_area.reset(new site_area_hover);
        m_area_tool.reset(new area_tool);
        m_mine_tool.reset(new mine_tool);

        card_location_base::clear();
    }
	
	virtual void site_hover(int sid)
	{
        if(m_time<=0)
        {
            return;
        }
        m_site_area->on_point(m_id,sid,nullptr, m_type);
	}

    virtual std::shared_ptr<area_hover> get_area_hover()
    {
        return m_area_tool->m_area_hover;
    }

    virtual std::shared_ptr<mine_tool> get_mine_tool()
    {
        return m_mine_tool;
    }

    virtual std::shared_ptr<site_area_hover> get_site_area()
    {
        return m_site_area;
    }

	virtual void do_business(const point &pt,double acc)
	{
		m_area_tool->on_point(m_id,pt,m_speed,m_type);
        m_site_area->on_point(m_id,0,this, m_type);
		handle_three_rates(pt);
	}
	void reset(std::shared_ptr<monkey_person> mp)
	{
		m_monkeyPerson = mp;
	}
	~person(){}
private:
	void handle_three_rates(const point & pt)
	{
		card_pos cp;
		cp.work_line=m_workLine;
		cp.biz_stat = get_stat();
		cp.x=pt.x;cp.y=pt.y;cp.z=pt.z;	
		const auto lm = m_area_tool->getLandmark();
		cp.enter_time = std::get<0>(lm)*1000;
		cp.area_id = std::get<3>(lm);
		put_three_rates(cp);
	}
	void on_timer()
	{    
		if(!m_mine_tool->is_attendance())
		  return;
		YA::_CARD_POS_ cp;
		uint64_t _time=0;
		point pt = getSmoothPoint(_time);
		const auto lm = m_area_tool->getLandmark();

		cp.enter_area_time = std::get<0>(lm)*1000;
		cp.rec_time = std::get<1>(lm);

		int32_t map_id = std::get<2>(lm);
		int32_t area_id = std::get<3>(lm);
		cp.map_id=map_id;cp.area_id=area_id;
		cp.landmark_id = std::get<4>(lm);
		cp.lm_direction = std::get<5>(lm);
		cp.landmark_dis=std::get<6>(lm);

		cp.biz_stat = get_stat();
		cp.down_time = m_mine_tool->get_down_time();
		cp.work_time = m_mine_tool->get_work_time();
		cp.is_on_duty= m_mine_tool->is_on_duty();
		log_info("on_timer here ...%d,%lld,%.2f,%.2f,%d,%d",m_id,_time,pt.x,pt.y,area_id,map_id);
		m_his_location_card->push(_time,pt,area_id,map_id);
		upt_card_pos(cp,pt);
	}
	point getSmoothPoint(uint64_t& t)
	{
		point pt;
		loc_point lp = m_smo_tool->smooth_strategy();
		m_speed = lp.m_speed;
		m_stat  = lp.m_stat;
		pt.x = lp.x;
		pt.y = -lp.y;
		t=lp.m_time;
		if(auto  p = m_monkeyPerson.lock() )
		{
			if(p->is_on_bus())
			{
				m_stat = 7;
				pt = p->getPoint(t);	
				log_info("getpoint_oncar:%d,%lld",m_id,t);
			}
		}
		return pt;
	}
};

struct car:card_location_base,card_area
{
	int m_vehicle_category_id=0;
    int m_vehicle_type_id=0;
	double m_acc =0;
    car(std::string type,uint32_t cardid,uint16_t needdisplay,int16_t t,int32_t deptid,
        int32_t categoryid, int type_id,int32_t level_id,uint32_t cid)
        :card_location_base(type,cardid,needdisplay,t,deptid,level_id,cid)
		,m_vehicle_category_id(categoryid)
        ,m_vehicle_type_id(type_id)
    {
        m_message_handle.reset(new card_message_handle(this));
		m_his_location_card.reset(new location_vehicle(m_id,m_type));
    }

	virtual void site_hover(int sid)
	{
        if(m_time<=0)
        {
            return;
        }
        m_site_area->on_point(m_id,sid,0, m_type);
	}

    virtual std::shared_ptr<area_hover> get_area_hover()
    {
        return m_area_tool->m_area_hover;
    }

    virtual std::shared_ptr<mine_tool> get_mine_tool()
    {
        return m_mine_tool;
    }

    virtual std::shared_ptr<site_area_hover> get_site_area()
    {
        return m_site_area;
    }

	virtual void do_business(const point &pt,double acc)
	{
		m_acc=acc;
		m_area_tool->on_point(m_id,pt,m_speed,m_type);
        m_site_area->on_point(m_id,0,this, m_type);
        m_mine_tool->on_point(m_id, m_type, m_vehicle_category_id);
		handle_three_rates(pt);
	}

    int get_vehicle_type_id()
    {
        return  m_vehicle_type_id;
    }

	~car(){}
private:
	void handle_three_rates(const point &pt)
	{
		card_pos cp;
		cp.biz_stat = get_stat();
		cp.x=pt.x;cp.y=pt.y;cp.z=pt.z;	
		const auto lm = m_area_tool->getLandmark();
		cp.enter_time = std::get<0>(lm)*1000;
		cp.area_id = std::get<3>(lm);
		cp.map_id = std::get<2>(lm);
		cp.vibration=m_acc;
		put_three_rates(cp);
	}
	void on_timer()
	{
		make_package();
		
	}
	int statbiz(int32_t special_id)
	{
		int status = get_stat();
		if(status == STATUS_LOST)
		{
			if(!m_area_tool->special_area())			
			{
				special_id = special_area_list::instance()->get_special_id(m_id,*this,m_vehicle_category_id);
				log_info("enter_special_area:%.2f,%2.f,id:%d,special_area_id:%d",x,y,m_id,special_id);
				if(special_id != -1)
					m_area_tool->change_area(m_id,m_speed,m_type,special_id);//自动拖车
			}
		}
		return status;
	}
	void make_package()
	{
		int32_t special_id=-1;
		YA::_CARD_POS_ cp;
		loc_point pt = getSmoothPoint();

		const auto lm = m_area_tool->getLandmark();
		cp.enter_area_time = std::get<0>(lm);
		cp.rec_time = std::get<1>(lm);
		uint32_t map_id = std::get<2>(lm);
		uint32_t area_id = std::get<3>(lm);
		cp.map_id =map_id;cp.area_id=area_id;
		cp.landmark_id = std::get<4>(lm);
		cp.lm_direction = std::get<5>(lm);
		cp.landmark_dis=std::get<6>(lm);
		int32_t biz_stat=statbiz(special_id);
		cp.biz_stat=biz_stat;
		cp.down_time = m_mine_tool->get_down_time();
		cp.work_time = m_mine_tool->get_work_time();
		//for now
		cp.is_on_duty=m_mine_tool->is_on_duty();
		upt_card_pos(cp,pt);
		m_his_location_card->push(pt.m_time,pt,area_id,map_id);
		if(biz_stat==STATUS_LOST && special_id != -1 && m_display==1)
		{
			cp.area_id = special_id;
			swsClientMgr.SendSpecialAreaProcess(cp);
		}
	}
	loc_point getSmoothPoint()
	{
		loc_point lp = m_smo_tool->smooth_strategy();
		m_speed = lp.m_speed;
		m_stat  = lp.m_stat;
		lp.y = -lp.y;
		return lp;
	}

};

loc_tool_main one_ct_message_handle::m_loc_tool;

uint64_t card_list::getId(uint32_t cardid,uint64_t type)
{
	return type<<32|cardid;
}

void card_list::init_staffer(int32_t id)
{
    std::string strategy = config.get("person.strategy","person1");
    std::string sql = "SELECT staff_id, s.card_id, c.card_type_id, s.dept_id, s.group_id, s.occupation_id, \
            ol.occupation_level_id,s.worktype_id,s.need_display,s.work_line\
            FROM dat_staff_extend s \
            LEFT JOIN dat_card c ON s.card_id = c.card_id \
            LEFT JOIN dat_occupation o ON s.occupation_id = o.occupation_id \
            LEFT JOIN dat_occupation_level ol ON ol.occupation_level_id = o.occupation_level_id \
            WHERE c.card_type_id = 1 AND s.duty_id = 0 AND c.state_id = 0";

    int type = CT_PERSON;
    std::string card_id_str = card_list::to_id64_str(type, static_cast<uint32_t>(id));
    if(-1 == id)
    {
        sql.append(";");
    }
    else
    {
        sql.append(" AND s.card_id = '");
        sql.append(card_id_str);
        sql.append("';");

        std_debug("基础数据 增加或修改人卡 sql=%s", sql.c_str());
        log_info("基础数据 增加或修改人卡 sql=%s", sql.c_str());
    }

    std::string Error;
    YADB::CDBResultSet DBRes;
    sDBConnPool.Query(sql.c_str(),DBRes,Error);
    int nCount = DBRes.GetRecordCount( Error );
    if (nCount < 1)
    {
        log_error("增加或修改失败，数据库中找不到: card_id=%s", card_id_str.c_str());
        return ;
    }

    std::unordered_map<uint64_t,std::shared_ptr<card_location_base>> map;
    while ( DBRes.GetNextRecod(Error) )
    {
        unsigned int staff_id  = 0;
        DBRes.GetField( "staff_id",staff_id, Error );

        std::string card_id;
        DBRes.GetField( "card_id",card_id, Error );

        uint32_t vsid = atoi(card_id.substr(3).c_str());

        unsigned int card_type_id  = 0;
        DBRes.GetField( "card_type_id",card_type_id, Error );

        int dept_id = 0;
        DBRes.GetField( "dept_id",dept_id, Error );

        int group_id = 0;
        DBRes.GetField( "group_id",group_id, Error );

        int occupation_id = 0;
        DBRes.GetField( "occupation_id",occupation_id, Error );

        int occupation_level_id = 0;
        DBRes.GetField( "occupation_level_id",occupation_level_id, Error );

        int need_display = 0;
        DBRes.GetField( "need_display",need_display, Error );
		
        int work_line = 0;
        DBRes.GetField( "work_line",work_line, Error );
        //for now;
        //staff_id = vsid;

        if(-1 == id)
        {
            std::shared_ptr<card_location_base> clb =
                    std::make_shared<person>(strategy,vsid,need_display,card_type_id,dept_id,occupation_level_id,staff_id,work_line);
            uint64_t cardid = getId(vsid,type);
            log_info("cardId:%llu,id:%d dept_id:%d,need_display:%d,card:%s:work_line:%d,staff_id:%d,type:%d",
                     cardid,vsid,dept_id,need_display,card_id.c_str(),work_line,staff_id,card_type_id);
            map.insert({cardid,clb});
        }
        else
        {
            auto card_id64 = card_list::to_id64(type, static_cast<uint32_t>(id));
            auto card_ptr = card_list::instance()->get(card_id64);
            if(card_ptr)
            {
                person* tmp_ptr= static_cast<person*>(card_ptr.get());
                tmp_ptr->m_display = static_cast<uint16_t>(need_display);
                tmp_ptr->m_deptid = dept_id;
                //group_id
                //occ_id
                tmp_ptr->m_level_id = occupation_level_id;
                //worktype_id
            }
            else
            {
                auto clb = std::make_shared<person>(strategy,vsid,need_display,card_type_id,dept_id,occupation_level_id,staff_id,work_line);
                card_list::instance()->add(card_id64, clb);
            }

            log_info("基础数据 增加或修改人卡成功：卡id:%d,卡type:%d dept_id:%d,need_display:%d,occupation_level_id:%d",
                     id,type,dept_id,need_display,occupation_level_id);
            std_debug("基础数据 增加或修改人卡成功：卡id:%d,卡type:%d dept_id:%d,need_display:%d,occupation_level_id:%d",
                     id,type,dept_id,need_display,occupation_level_id);
        }
    }

    if(-1 == id)
    {
        log_info( "init_staffer. The record count=%d\n", nCount );
        card_list::instance()->add(map);
    }
}

void card_list::init_vehicle(int32_t id)
{
    std::string strategy = config.get("car.strategy","car1");
    std::string sql = "SELECT ve.vehicle_id, ve.card_id, c.card_type_id, \
                        ve.dept_id, ve.group_id, v.vehicle_type_id, vt.vehicle_level_id, \
                        vt.is_railroad AS vt_is_railroad,ve.need_display ,ve.power_alarm,\
                        vt.vehicle_category_id,v.bigger_car_flag,vc.over_speed \
                        FROM dat_vehicle_extend ve \
                        LEFT JOIN dat_vehicle v ON ve.vehicle_id = v.vehicle_id \
                        LEFT JOIN dat_card c ON ve.card_id = c.card_id \
                        LEFT JOIN dat_dept d ON ve.dept_id = d.dept_id \
                        LEFT JOIN dat_group g ON ve.group_id = g.group_id \
                        LEFT JOIN dat_vehicle_type vt ON v.vehicle_type_id = vt.vehicle_type_id \
                        LEFT JOIN dat_vehicle_category vc ON vc.vehicle_category_id = vt.vehicle_category_id \
                        WHERE c.card_type_id = 2 AND c.state_id = 0";

    int type = CT_VEHICLE;
    std::string card_id_str = card_list::to_id64_str(type, static_cast<uint32_t>(id));
    if(-1 == id)
    {
        sql.append(";");
    }
    else
    {
        sql.append(" AND ve.card_id ='");
        sql.append(card_id_str);
        sql.append("';");

        std_debug("基础数据 增加或修改车卡 sql=%s", sql.c_str());
        log_info("基础数据 增加或修改车卡 sql=%s", sql.c_str());
    }

    std::string Error;
    YADB::CDBResultSet DBRes;
    sDBConnPool.Query(sql.c_str(),DBRes,Error);
    int nCount = DBRes.GetRecordCount( Error );
    if (nCount < 1)
    {
        log_error("增加或修改失败，数据库中找不到: card_id=%s", card_id_str.c_str());
        return ;
    }

    std::unordered_map<uint64_t,std::shared_ptr<card_location_base>> map;
    while ( DBRes.GetNextRecod(Error) )
    {
        unsigned int vehicle_id  = 0;
        DBRes.GetField( "vehicle_id",vehicle_id, Error );

        std::string card_id;
        DBRes.GetField( "card_id",card_id, Error );

        uint32_t vsid = atoi(card_id.substr(3).c_str());

        unsigned int card_type_id  = 0;
        DBRes.GetField( "card_type_id",card_type_id, Error );

        int dept_id = 0;
        DBRes.GetField( "dept_id",dept_id, Error );

        int group_id = 0;
        DBRes.GetField( "group_id",group_id, Error );

        int vehicle_type_id = 0;
        DBRes.GetField( "vehicle_type_id",vehicle_type_id, Error );

        int vehicle_level_id = 0;
        DBRes.GetField( "vehicle_level_id",vehicle_level_id, Error );

        int need_display = 0;
        DBRes.GetField( "need_display",need_display, Error );

        int power_alarm = 0;
        DBRes.GetField( "power_alarm",power_alarm, Error );

        int vehicle_category_id = 0;
        DBRes.GetField( "vehicle_category_id",vehicle_category_id, Error );

        int bigger_car_flag= 0;
        DBRes.GetField( "bigger_car_flag",bigger_car_flag, Error );

        double over_speed= 0;
        DBRes.GetField( "over_speed",over_speed, Error );

        //for now
        //vehicle_id = vsid;

        if(-1 == id)
        {
            auto clb = std::make_shared<car>(strategy,vsid,need_display,card_type_id,
                                             dept_id,vehicle_category_id, vehicle_type_id,vehicle_level_id,vehicle_id);
            uint64_t cardid = getId(vsid,type);
            log_info("cardId:%llu,id:%d dept_id:%d,need_display:%d-cardid:%s,categoryid:%d,vchile_id:%d,type:%d",
                     cardid,vsid,dept_id,need_display,card_id.c_str(),vehicle_category_id,vehicle_id,card_type_id);
            map.insert({cardid,clb});
        }
        else
        {
            auto card_id64 = card_list::to_id64(type, static_cast<uint32_t>(id));
            auto card_ptr = card_list::instance()->get(card_id64);
            if(card_ptr)
            {
                car* tmp_ptr= static_cast<car*>(card_ptr.get());
                tmp_ptr->m_display = static_cast<uint16_t>(need_display);
                tmp_ptr->m_deptid = dept_id;
                tmp_ptr->m_vehicle_category_id = vehicle_category_id;
                tmp_ptr->m_vehicle_type_id = vehicle_type_id;
                tmp_ptr->m_level_id = vehicle_level_id;
            }
            else
            {
                auto clb = std::make_shared<car>(strategy,vsid,need_display,card_type_id,dept_id,
                                                 vehicle_category_id, vehicle_type_id,vehicle_level_id,vehicle_id);
                card_list::instance()->add(card_id64, clb);
            }

            log_info("基础数据 增加或修改车卡成功：卡id:%d,卡type:%d dept_id:%d,need_display:%d,categoryid:%d",
                     vsid,type,dept_id,need_display,vehicle_category_id);
            std_debug("基础数据 增加或修改车卡成功：卡id:%d,卡type:%d dept_id:%d,need_display:%d,categoryid:%d",
                     vsid,type,dept_id,need_display,vehicle_category_id);
        }
    }

    if(-1 == id)
    {
        log_info( "init_vehicle. The record count=%d\n", nCount );
        card_list::instance()->add(map);
    }
}
#if 0
void card_list::init_vehicle()
{
	std::unordered_map<uint64_t,std::shared_ptr<card_location_base>> map;
	std::string strategy = config.get("car.strategy","car1");
	const char *sql = "SELECT ve.vehicle_id, ve.card_id, c.card_type_id, \
						ve.dept_id, ve.group_id, v.vehicle_type_id, vt.vehicle_level_id, \
						vt.is_railroad AS vt_is_railroad,ve.need_display ,ve.power_alarm,\
						vt.vehicle_category_id,v.bigger_car_flag,vc.over_speed \
						FROM dat_vehicle_extend ve \
						LEFT JOIN dat_vehicle v ON ve.vehicle_id = v.vehicle_id \
						LEFT JOIN dat_card c ON ve.card_id = c.card_id \
						LEFT JOIN dat_dept d ON ve.dept_id = d.dept_id \
						LEFT JOIN dat_group g ON ve.group_id = g.group_id \
						LEFT JOIN dat_vehicle_type vt ON v.vehicle_type_id = vt.vehicle_type_id \
						LEFT JOIN dat_vehicle_category vc ON vc.vehicle_category_id = vt.vehicle_category_id \
						WHERE c.card_type_id = 2 AND c.state_id = 0;";
	std::string Error;
	YADB::CDBResultSet DBRes;
	sDBConnPool.Query(sql,DBRes,Error);
	int nCount = DBRes.GetRecordCount( Error );
	if (nCount > 0)
	{
        log_info( "init_vehicle. The record count=%d\n", nCount );

		while ( DBRes.GetNextRecod(Error) )
		{
			unsigned int vehicle_id  = 0;
			DBRes.GetField( "vehicle_id",vehicle_id, Error );

			std::string card_id;
			DBRes.GetField( "card_id",card_id, Error );

			uint32_t vsid = atoi(card_id.substr(3).c_str());
  		
			unsigned int card_type_id  = 0;
			DBRes.GetField( "card_type_id",card_type_id, Error );

			int dept_id = 0;
			DBRes.GetField( "dept_id",dept_id, Error );

			int group_id = 0;
			DBRes.GetField( "group_id",group_id, Error );

			int vehicle_type_id = 0;
			DBRes.GetField( "vehicle_type_id",vehicle_type_id, Error );

			int vehicle_level_id = 0;
			DBRes.GetField( "vehicle_level_id",vehicle_level_id, Error );

			int need_display = 0;
			DBRes.GetField( "need_display",need_display, Error );

			int power_alarm = 0;
			DBRes.GetField( "power_alarm",power_alarm, Error );

			int vehicle_category_id = 0;
			DBRes.GetField( "vehicle_category_id",vehicle_category_id, Error );

			int bigger_car_flag= 0;
			DBRes.GetField( "bigger_car_flag",bigger_car_flag, Error );

			double over_speed= 0;
			DBRes.GetField( "over_speed",over_speed, Error );
  		
			//for now
			vehicle_id = vsid;

            std::shared_ptr<card_location_base> clb = std::make_shared<car>(strategy,vehicle_id,
                  need_display,card_type_id,dept_id,vehicle_category_id, vehicle_type_id,vehicle_level_id);
			uint64_t cardid = getId(vehicle_id,2);
			log_info("cardId:%llu,vehicle_id:%d dept_id:%d,need_display:%d---cardid:%s,categoryid:%d",cardid,vehicle_id,dept_id,need_display,card_id.c_str(),vehicle_category_id);
			map.insert({cardid,clb});
		}
	}
  
	card_list::instance()->add(map);
}

void card_list::init_staffer()
{
	std::unordered_map<uint64_t,std::shared_ptr<card_location_base>> map;
	std::string strategy = config.get("person.strategy","person1");
	const char *sql = "SELECT staff_id, s.card_id, c.card_type_id, s.dept_id, s.group_id, s.occupation_id, \
						ol.occupation_level_id,s.worktype_id,s.need_display \
						FROM dat_staff_extend s \
						LEFT JOIN dat_card c ON s.card_id = c.card_id \
						LEFT JOIN dat_occupation o ON s.occupation_id = o.occupation_id \
						LEFT JOIN dat_occupation_level ol ON ol.occupation_level_id = o.occupation_level_id \
						WHERE c.card_type_id = 1 AND s.duty_id = 0 AND c.state_id = 0;";
	std::string Error;
	YADB::CDBResultSet DBRes;
	sDBConnPool.Query(sql,DBRes,Error);
	int nCount = DBRes.GetRecordCount( Error );
	if (nCount > 0)
	{
		log_info( "init_staffer. The record count=%d\n", nCount );

		while ( DBRes.GetNextRecod(Error) )
		{
			unsigned int staff_id  = 0;
			DBRes.GetField( "staff_id",staff_id, Error );

			std::string card_id;
			DBRes.GetField( "card_id",card_id, Error );

			uint32_t vsid = atoi(card_id.substr(3).c_str());
  		
			unsigned int card_type_id  = 0;
			DBRes.GetField( "card_type_id",card_type_id, Error );
  		
			int dept_id = 0;
			DBRes.GetField( "dept_id",dept_id, Error );

			int group_id = 0;
			DBRes.GetField( "group_id",group_id, Error );

			int occupation_id = 0;
			DBRes.GetField( "occupation_id",occupation_id, Error );

			int occupation_level_id = 0;
			DBRes.GetField( "occupation_level_id",occupation_level_id, Error );

			int need_display = 0;
			DBRes.GetField( "need_display",need_display, Error );

			//for now;
			staff_id = vsid;

			std::shared_ptr<card_location_base> clb = std::make_shared<person>(strategy,staff_id,need_display,card_type_id,dept_id,occupation_level_id);
			uint64_t cardid = getId(staff_id,1);
			log_info("cardId:%llu,staff_id:%d dept_id:%d,need_display:%d--c-ard:%s",cardid,staff_id,dept_id,need_display,card_id.c_str());
			map.insert({cardid,clb});
		}
	}
  
	card_list::instance()->add(map);
}
#endif
void card_list::init_card_from_db()
{
    init_staffer(-1);
    init_vehicle(-1);
}

void card_list::load_his_card_postion_from_db()
{
    load_his_card_postion_vehicle();
    load_his_card_postion_staff();
	run();

    for(auto&iter: m_map)
    {
        auto card_ptr = iter.second;
        auto mine_tool_ptr = card_ptr->get_mine_tool();
        if(mine_tool_ptr->is_attendance())
        {
            auto str = tool_time::to_str_ex( tool_time::to_ms(mine_tool_ptr->m_attendance_start_time));
            std_debug("加载考勤,考勤开始时间： %s, 卡id=%d，卡type=%d", str.c_str(), card_ptr->m_id, card_ptr->m_type);
            log_info("加载考勤,考勤开始时间： %s, 卡id=%d，卡type=%d", str.c_str(), card_ptr->m_id, card_ptr->m_type);
        }
    }

    auto area_map = area_list::instance()->m_map;
    for(auto&iter: area_map)
    {
        auto area_ptr = iter.second;
        if(area_ptr->m_person_count)
        {
            std_debug("加载区域人数： 区域id=%d，区域人数=%d",area_ptr->m_id, area_ptr->m_person_count.load());
            log_info("加载区域人数： 区域id=%d，区域人数=%d",area_ptr->m_id, area_ptr->m_person_count.load());
        }

        if(area_ptr->m_vehicle_count)
        {
            std_debug("加载区域车数： 区域id=%d，区域车数=%d",area_ptr->m_id, area_ptr->m_vehicle_count.load());
            log_info("加载区域车数： 区域id=%d，区域车数=%d",area_ptr->m_id, area_ptr->m_vehicle_count.load());
        }
    }
}

void card_list::load_his_card_postion_vehicle()
{
    const char *sql = "select l.card_id, l.cur_time, l.x, l.y, l.z, l.map_id, la.area_id, l.state, \
            case when l.cur_time >= date_sub(now(), interval 2 minute) then l.speed else 0 end as speed, \
            l.mileage, la.enter_time, att.start_time, \
            att.end_time, \
            l.landmark_id, l.direction_mapper_id, l.landmark_dist \
            from rt_location l, rt_location_area la, rt_att_vehicle att, dat_card c, dat_vehicle_extend v \
            where l.card_id = c.card_id and l.card_id = la.card_id and l.card_id = att.card_id and l.card_id=v.card_id \
            and c.state_id=0;";
    std::string Error;
    YADB::CDBResultSet DBRes;
    sDBConnPool.Query(sql,DBRes,Error);
    if(!Error.empty())
        log_error("load_his_card_postion_vehicle列表 Error,%s",Error.c_str());
    uint64_t nCount = DBRes.GetRecordCount( Error );
    if (nCount > 0)
    {
        log_info( "load_his_card_postion_vehicle. The record count=%ld\n", nCount );

        while ( DBRes.GetNextRecod(Error) )
        {
            std::string card_id  = "";
            DBRes.GetField( "card_id",card_id, Error );

            uint32_t id = tool_other::id64_to_id(card_id);
            int type = tool_other::id64_to_type(card_id);

            auto temp_ptr = card_list::instance()->get(card_list::to_id64(type, id));
            if(!temp_ptr || !temp_ptr->is_vehicle())
            {
                log_error("全局卡列表中找不到卡，卡id=%d，卡type=%d", id, type);
                continue;
            }

            auto card_ptr = static_cast<car*>(temp_ptr.get());

            double x = 0;
            DBRes.GetField( "x",x, Error );

            double y = 0;
            DBRes.GetField( "y",y, Error );

            double z = 0;
            DBRes.GetField( "z",z, Error );

            int map_id  = 0;
            DBRes.GetField( "map_id",map_id, Error );

            int area_id  = 0;
            DBRes.GetField( "area_id",area_id, Error );

            int state  = 0;
            DBRes.GetField( "state",state, Error );

            double speed = 0;
            DBRes.GetField( "speed",speed, Error );

            std::string enter_time  = "";
            DBRes.GetField( "enter_time",enter_time, Error );

            std::string start_time  = "";
            DBRes.GetField( "start_time",start_time, Error );

            std::string end_time  = "";
            DBRes.GetField( "end_time",end_time, Error );

            int landmark_id  = 0;
            DBRes.GetField( "landmark_id",landmark_id, Error );

            int direction_mapper_id  = 0;
            DBRes.GetField( "direction_mapper_id",direction_mapper_id, Error );

            double landmark_dist = 0;
            DBRes.GetField( "landmark_dist",landmark_dist, Error );

            card_ptr->x = x;
            card_ptr->y = y;
            card_ptr->z = z;

            auto area = area_list::instance()->get(area_id);
            if(area == nullptr)
            {
                log_error("load_vehicle...area_list 找不到区域：区域id=%d", area_id);
                continue;
            }
            area->m_vehicle_count++;

            point pt = *card_ptr;
            card_ptr->m_area_tool->m_area_hover = std::make_shared<area_hover>( area, pt,speed);
            auto area_hover_ptr = card_ptr->get_area_hover();

            auto e_t = tool_time::to_time_ex(enter_time);
            area_hover_ptr->m_enter_time = std::chrono::system_clock::to_time_t(e_t);

            //int map_id  = 0;
            //int state  = 0;
            card_ptr->m_speed = speed;

            if(end_time.empty())
            {
                auto mine_tool_ptr = card_ptr->get_mine_tool();
                mine_tool_ptr->m_attendance_start_time = tool_time::to_time_ex(start_time);
                mine_tool_ptr->m_stat_attendance = AS_ATTENDANCE;
            }

            area_hover_ptr->landmark_id = landmark_id;
            area_hover_ptr->landmark_dir = direction_mapper_id;
            area_hover_ptr->landmark_dis = landmark_dist;

            card_ptr->m_time = tool_time::now_to_ms();
        }
    }
}

void card_list::load_his_card_postion_staff()
{
    const char *sql = "select l.card_id, l.cur_time, l.x, l.y, l.z, l.map_id, la.area_id, l.state, \
            case when l.cur_time >= date_sub(now(), interval 2 minute) then l.speed else 0 end as speed, \
            l.mileage, la.enter_time, att.start_time, \
            att.end_time, \
            l.landmark_id, l.direction_mapper_id, l.landmark_dist \
            from rt_location l, rt_location_area la, rt_att_staff att, dat_card c, dat_staff_extend s \
            where l.card_id = c.card_id and l.card_id = la.card_id and l.card_id = att.card_id and l.card_id=s.card_id\
            and c.state_id=0;";
    std::string Error;
    YADB::CDBResultSet DBRes;
    sDBConnPool.Query(sql,DBRes,Error);
    if(!Error.empty())
        log_error("load_his_card_postion_vehicle列表 Error,%s",Error.c_str());
    uint64_t nCount = DBRes.GetRecordCount( Error );
    if (nCount > 0)
    {
        log_info( "load_his_card_postion_vehicle. The record count=%ld\n", nCount );

        while ( DBRes.GetNextRecod(Error) )
        {
            std::string end_time  = "";
            DBRes.GetField( "end_time",end_time, Error );
            if(!end_time.empty()) // 已升井，不再读入
            {
                continue;
            }

            std::string card_id  = "";
            DBRes.GetField( "card_id",card_id, Error );

            uint32_t id = tool_other::id64_to_id(card_id);
            int type = tool_other::id64_to_type(card_id);

            auto temp_ptr = card_list::instance()->get(card_list::to_id64(type, id));
            if(!temp_ptr || !temp_ptr->is_person())
            {
                log_error("全局卡列表中找不到卡，卡id=%d，卡type=%d", id, type);
                continue;
            }

            auto card_ptr = static_cast<car*>(temp_ptr.get());

            double x = 0;
            DBRes.GetField( "x",x, Error );

            double y = 0;
            DBRes.GetField( "y",y, Error );

            double z = 0;
            DBRes.GetField( "z",z, Error );

            int map_id  = 0;
            DBRes.GetField( "map_id",map_id, Error );

            int area_id  = 0;
            DBRes.GetField( "area_id",area_id, Error );

            int state  = 0;
            DBRes.GetField( "state",state, Error );

            double speed = 0;
            DBRes.GetField( "speed",speed, Error );

            std::string enter_time  = "";
            DBRes.GetField( "enter_time",enter_time, Error );

            std::string start_time  = "";
            DBRes.GetField( "start_time",start_time, Error );

            int landmark_id  = 0;
            DBRes.GetField( "landmark_id",landmark_id, Error );

            int direction_mapper_id  = 0;
            DBRes.GetField( "direction_mapper_id",direction_mapper_id, Error );

            double landmark_dist = 0;
            DBRes.GetField( "landmark_dist",landmark_dist, Error );

            card_ptr->x = x;
            card_ptr->y = y;
            card_ptr->z = z;

            auto area = area_list::instance()->get(area_id);
            if(area == nullptr)
            {
                log_error("area_list 找不到区域：区域id=%d", area_id);
                continue;
            }
            area->m_person_count++;

            point pt = *card_ptr;
            card_ptr->m_area_tool->m_area_hover = std::make_shared<area_hover>(area,pt,speed);
            auto area_hover_ptr = card_ptr->get_area_hover();

            auto e_t = tool_time::to_time_ex(enter_time);
            area_hover_ptr->m_enter_time = std::chrono::system_clock::to_time_t(e_t);
			log_info("load_staff...%d,areaid:%d,mapid:%d",id,area->id(),area->mapid());

            //int map_id  = 0;
            //int state  = 0;
            card_ptr->m_speed = speed;

            if(end_time.empty())
            {
                auto mine_tool_ptr = card_ptr->get_mine_tool();
                mine_tool_ptr->m_attendance_start_time = tool_time::to_time_ex(start_time);
                mine_tool_ptr->m_stat_attendance = AS_ATTENDANCE;
            }

            area_hover_ptr->landmark_id = landmark_id;
            area_hover_ptr->landmark_dir = direction_mapper_id;
            area_hover_ptr->landmark_dis = landmark_dist;

            card_ptr->m_time = tool_time::now_to_ms();
        }
    }
}

void card_list::on_message(zloop<task*> *loop,const message_locinfo&loc,bool is_history)
{
	//std::shared_ptr<card_location_base>c=get(loc.m_card_id);
	uint64_t cardid = getId(loc.m_card_id,loc.m_card_type);
	const auto c=get(cardid);
	if(c==nullptr)
	{
		log_warn("数据库中未定义该卡的信息，card_id=%d", loc.m_card_id);
		return;
	}
	log_info("card message:site=%d,ant=%d,card=%d,tof=%lld,rav=%02X,acc=%02X,rssi=%d,stamp=%llu",
			loc.m_site_id,loc.m_ant_id,loc.m_card_id,loc.m_tof,loc.m_rav,loc.m_acc,loc.m_rssi,loc.m_time_stamp);

	c->on_message(loop,loc,is_history);
}
struct local_visit:visitor<std::shared_ptr<card_location_base>>
{
	bool visit(std::shared_ptr<card_location_base> c)
	{
		c->on_timer();
		return true;	
	}
};
void card_list::onTimer()
{
	local_visit lv;
	while(!m_bflag)
	{
		card_list::instance()->accept(lv);	
		std::this_thread::sleep_for(std::chrono::seconds(1));
	}
}
//-----------------card_location_base..
card_location_base::card_location_base(std::string type,uint32_t id,uint16_t dis,int16_t t,int32_t deptid,int32_t level_id,uint32_t cid)
	:card(id,dis,t,deptid,level_id,cid)
{
    select_tool_manage::instance()->create_tool(type,m_sel_tool,m_smo_tool);
}

void card_location_base::do_status(STATUS_CARD st)
{
    module_mgr::do_status(st, m_id, m_type);
}

void card_location_base::on_location(const std::vector<point>&vp,const std::vector<loc_message> &lm )
{
	//ct timestamp;
	//m_ct = lm[0].m_card_ct;
	//m_time = lm[0].m_loc_time;

    loc_point pt = m_sel_tool->select_solution(vp,lm);
	pt.y=-pt.y;
	if(pt.m_useless)
	{
		x = pt.x;
		y = pt.y;

		Msg m;
		m.type=m_type;m.x=(int)x;m.y=(int)y;m.cmd=CMD_HANDLE;m.cardid=m_type<<32|m_id;
		cardMgr::instance()->tryPut(m);
		double acc = lm[0].m_acc;
		log_info("useful:card_id:%d,ct:%d,timestamp:%llu, loc_point,x:%.2f,y:%.2f acc:%.2f",m_id,m_ct,m_time,pt.x,pt.y,acc);
		do_business(pt,acc);
	}
}

void card_location_base::on_message(zloop<task*> * loop,const message_locinfo&loc,bool is_history)
{
	m_ct = loc.m_card_ct;
	m_time = loc.m_time_stamp;
	m_message_handle->on_message(loop,loc,is_history);
}

//前端推送位置函数
void card_location_base::upt_card_pos(YA::_CARD_POS_ &cp,const point &pt)
{
	cp.x = pt.x;
	cp.y = pt.y;
	cp.z = pt.z;
	cp.Type=m_type;
	cp.ID = m_id;
	cp.speed = abs(ceil(m_speed));
	cp.running_stat = m_stat;
	cp.dept_id = m_deptid;
	cp.display=m_display;
	cp.rec_time=m_time;
	cp.level_id = m_level_id;

	swsTimerThrd.upt_card_pos(cp);
}
void card_location_base::del_card_pos()
{
	YA::_CARD_POS_ cp;
	cp.ID = m_id;
	cp.Type=m_type;
	swsTimerThrd.del_card_pos(cp);
}
int  card_location_base::get_stat()
{
	//盲区>呼救>呼叫>超时>超速>正常
    uint64_t now = time(0)*1000;
    if(now-m_time>CARD_LOST_TIME_OUT)
    {
        return STATUS_LOST;
    }
    else if(auto ev_ptr = event_list::instance()->get_event_card(m_id, m_type, ET_CARD_HELP))
    {
        return  (ES_DEAL_HELP == ev_ptr->m_status) ?  STATUS_HELP_DEALED : STATUS_HELP;
    }
    else if(CALL_NONE != get_mine_tool()->m_status_call)
    {
        return  STATUS_CALL;
    }
    else if(event_list::instance()->get_event_card(m_id, m_type,
                is_person()? ET_CARD_AREA_OVER_TIME_PERSON: ET_CARD_AREA_OVER_TIME_VEHICLE))
    {
        return  STATUS_AREA_OVER_TIME;
    }
    else if(event_list::instance()->get_event_card(m_id, m_type, ET_CARD_OVER_SPEED))
    {
        return  STATUS_OVER_SPEED;
    }

    return STATUS_NORMAL;
}

void  card_location_base::clear()
{
//	uint16_t m_display;			//1显示0不显示，往前端推送
    m_speed=0;			//速度
    m_is_attendance=0;	//井上井下状态  0初始状态 1 井上 2 井下
    m_stat=0;			//运动静止状态
    //m_ct;				//ct
    m_time=0;			//时间戳
}
void card_location_base::put_three_rates(card_pos & cp)
{
	cp.rec_time=m_time;cp.type=m_type;cp.id=m_id;
	cp.identifier_id=m_cid;cp.running_stat=m_stat;cp.final_v=m_speed;
	log_info("three_rates:type:%d,id:%d,cid:%d",cp.type,cp.id,cp.identifier_id);
	three_rates::get_instance()->put(cp);
}
card_location_base::~card_location_base()
{
}
template<> std::shared_ptr<card_list> 
single_base<card_list, uint64_t, std::shared_ptr<card_location_base>>::m_instance=std::make_shared<card_list>();