server/module_service/module_attendance_person.h

#ifndef MODULE_ATTENDANCE_PERSON_H
#define MODULE_ATTENDANCE_PERSON_H

/**
  *@brief 人员考勤模块 2018-08-26 戴月腾修改
  *主要是针对人卡进行考勤，人卡从井上切换到井下为考勤开始，人卡从井下切换到井上为考勤结束
  *@author 陈欧美
  *@date 2018-08-03
*/

#include"math.h"
#include <memory>
#include <mutex>
#include <map>
#include <string>
#include <chrono>
#include <vector>
#include<card.h>
#include"ant.h"
#include"area.h"
#include"site_area.h"
#include"module_const.h"
#include"module_area.h"

/**
 * @brief 主要是针对人卡进行考勤，人卡从井上切换到井下为考勤开始，人卡从井下切换到井上为考勤结束
 */
class module_attendance_person:public singleton_base<module_attendance_person>
{
private:
    friend class singleton_base<module_attendance_person>;
    module_attendance_person()
    {
    }

public:
    /**
     * @brief 进入分站覆盖区域处理，考勤
     * @param card_ptr
     * @param site_ptr
     */
    void enter_site(std::shared_ptr<card_location_base> card_ptr, std::shared_ptr<site> site_ptr)
    {
        auto site_area_ptr = card_ptr->get_site_area();
        auto mine_tool_ptr = card_ptr->get_mine_tool();

        // 从井下切换到井上为考勤结束
        if(site_ptr->is_up_site())
        {
            if(mine_tool_ptr->is_attendance())
            {
                //考勤结束
                mine_tool_ptr->m_stat_attendance=AS_NOT_ATTENDANCE;

                //作为一条结束考勤记录保存到数据库
                tool_db::save_attendance(card_ptr);

                person_card_up_mine(card_ptr);

                log_info("人卡考勤结束：卡id=%d，卡type=%d，分站id=%d,分站reader_type_id=%d,stat_attendance=%d",
                         card_ptr->m_id, card_ptr->m_type,
                         site_ptr->m_id,site_ptr->m_reader_type_id,mine_tool_ptr->m_stat_attendance);
            }
        }
        else// 从井上切换到井下为考勤开始
        {
            if(!mine_tool_ptr->is_attendance())
            {
                //考勤开始
                mine_tool_ptr->m_stat_attendance=AS_ATTENDANCE;

                mine_tool_ptr->m_attendance_start_time=
                        std::chrono::system_clock::time_point(std::chrono::milliseconds(card_ptr->m_time));

                //作为一条开始考勤记录保存到数据库
                tool_db::save_attendance(card_ptr);

                log_info("人卡考勤开始：卡id=%d，卡type=%d，分站id=%d,分站reader_type_id=%d,stat_attendance=%d",
                         card_ptr->m_id, card_ptr->m_type,
                         site_ptr->m_id,site_ptr->m_reader_type_id,mine_tool_ptr->m_stat_attendance);
            }
        }
    }

//    /**
//     * @brief 离开现有分站处理，记录现有分站的进出时间和地点
//     * @param card_ptr
//     * @param site_ptr
//     */
//    void leave_site(std::shared_ptr<card_location_base> card_ptr, std::shared_ptr<site> site_ptr)
//    {

//    }

    /**
     * @brief 手工升井函数
     */
    void handle_up_mine(sio::message::ptr const& data)
    {
        std::vector<sio::message::ptr> card_vec;
        if(!tool_map::try_get_value(card_vec, JSON_ROOT_KEY_DATA, data) || card_vec.size() == 0)
        {
            log_error("手工升井，web发来的数据data字段为空 或者不是数组");
            return;
        }

        std::vector<sio::message::ptr>::const_iterator it_card = card_vec.begin();
        int type = 0;
        std::string s_card_id;
        for(; it_card != card_vec.end(); ++it_card)
        {
            if(!tool_map::try_get_value(s_card_id, JSON_KEY_CALL_CARD_CARD_ID, (*it_card))
               ||!tool_map::try_get_value(type, JSON_KEY_CALL_CARD_CARD_TYPE_ID, (*it_card)))
            {
                log_error("手工升井，web发来的数据 card_id 或 card_type格式不对");
                continue;
            }

            uint32_t id = tool_other::id64_to_id(s_card_id);
            auto card_ptr = card_list::instance()->get(card_list::to_id64(type, id));
            if(card_ptr && card_ptr->is_person())
            {
                std_debug("手工升井，处理，卡id=%d，卡type=%d", id, type);
                log_info("手工升井，处理，卡id=%d，卡type=%d", id, type);

                auto mine_tool_ptr = card_ptr->get_mine_tool();
                if(mine_tool_ptr->is_attendance())
                {
                    //考勤结束
                    mine_tool_ptr->m_stat_attendance=AS_NOT_ATTENDANCE;

                    //作为一条结束考勤记录保存到数据库
                    tool_db::save_attendance(card_ptr);
                }

                auto area_hover_ptr = card_ptr->get_area_hover();
                if(0!=area_hover_ptr->id() && 0!=area_hover_ptr->mapid())
                {
                    module_area::save_his_area_location_leave(card_ptr);
                }

                person_card_up_mine(card_ptr);
            }
            else
            {
                log_error("手工升井，在全局列表中找不到卡，卡id=%d，卡type=%d", id, type);
            }
        }
    }

private:
    ///1.人卡升井要发送json串给前端。 具体看card_up_mine函数，
    ///3.人卡升井要清除卡相关信息，区域相关，分站相关，考勤相关，清除定时器，
    ///速度，状态 呼救 呼叫 告警相关。即保留基础信息，其他的重置。
    static void person_card_up_mine(std::shared_ptr<card_location_base> card_ptr)
    {
        if (card_ptr->m_display)
        {
            std::string str = to_json_card_up(card_ptr);
            if(!str.empty())
            {
                tool_other::send_json(JSON_CMD_VALUE_PUSH, str);
            }
        }
		//删除
		card_ptr->del_card_pos();

        // 升井 删除所有报警信息
        for(int i=0; i < CARD_EVENT_COUNT_MAX; i++ )
        {
            if (i == EVENT_TYPE::ET_CARD_LOW_POWER_SERIOUS)
            {
                continue;
            }

            auto ev_ptr = event_list::instance()->get_event_card(
                        card_ptr->m_id, card_ptr->m_type, static_cast<EVENT_TYPE>(i));
            if(ev_ptr && !ev_ptr->is_end()) //
            {
                event_list::copy_event(card_ptr, ev_ptr);

                ev_ptr->m_status = ES_END;

                event_list::save_event(ev_ptr);
            }
        }

        card_ptr->clear();
    }

    ///升井json发给web
    static std::string to_json_card_up(std::shared_ptr<card_location_base> card_ptr)
    {
        auto site_area_ptr = card_ptr->get_site_area();
        if(!site_area_ptr || site_area_ptr->is_invalid())
        {
            return "";
        }

        auto mine_tool_ptr = card_ptr->get_mine_tool();

        rapidjson::Document doc(rapidjson::kObjectType);
        rapidjson::Value data(rapidjson::kArrayType);
        rapidjson::Document::AllocatorType& allocator=doc.GetAllocator();

        //卡号
        std::string id = card_list::to_id64_str(card_ptr->m_type, card_ptr->m_id);
        tool_json::push_back(data, id, allocator);

        //x,y坐标
        data.PushBack(card_ptr->x, allocator);
        data.PushBack(card_ptr->y, allocator); //CFunctions::round(card->y_offset_after(),2)

        //入井时间戳
        uint64_t t = tool_time::to_ms(mine_tool_ptr->m_attendance_start_time);	//转为ms
        data.PushBack(t, allocator);

        //进入区域时间戳
        data.PushBack(0, allocator);

        //接收时间戳
        data.PushBack(0, allocator);
        //工作时长
        t = tool_time::now_to_ms() - tool_time::to_ms(mine_tool_ptr->m_attendance_start_time);	//转为ms
        data.PushBack(t, allocator);

        //地图编号
        data.PushBack(0, allocator);
        //区域编号
        data.PushBack(0, allocator);
        //部门编号
        data.PushBack(card_ptr->m_deptid, allocator);

        //状态
        data.PushBack(0, allocator);
        //运行状态
        data.PushBack(card_ptr->m_stat, allocator);
        //业务状态
        data.PushBack(0, allocator);
        //速度
        data.PushBack(card_ptr->m_speed, allocator);

        doc.AddMember(JSON_ROOT_KEY_CMD,JSON_CMD_VALUE_UP_MINE, 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();
    }
};

#endif // MODULE_ATTENDANCE_PERSON_H