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"
#include "module_meta_date_changed.h"
#include "mine_module/MineCardManager.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)
    {
        // 从井下切换到井上为考勤结束
        if(site_ptr->is_up_site())
        {
            up_mine(card_ptr, site_ptr);
            //检查井下是否超员--是否需要取消
            CMineCardManager::instance()->OnPersonUp(card_ptr);
        }
        else// 从井上切换到井下为考勤开始
        {
            auto mine_tool_ptr = card_ptr->get_mine_tool();
            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::now();

                //作为一条开始考勤记录保存到数据库
                db_tool::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);
            }

            //检查井下是否超员
            CMineCardManager::instance()->OnPersonDown(card_ptr);
        }
    }

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

//    }

    ///升井或收到web的删除卡命令  site_ptr==nullptr表示收到web的删除卡命令
    /// 保存考勤记录，发升井json，清理卡
    static void up_mine(std::shared_ptr<card_location_base> card_ptr, std::shared_ptr<site> site_ptr)
    {
        auto mine_tool_ptr = card_ptr->get_mine_tool();
        if(!mine_tool_ptr->is_attendance())
        {
            return;
        }

        //考勤结束
        mine_tool_ptr->m_stat_attendance=AS_NOT_ATTENDANCE;

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

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

        to_json_card_up_one(card_ptr, datas, allocator);
        module_meta_date_changed::clear_card(card_ptr);

        //升井json发给web
        if(datas.Size() > 0)
        {
            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, datas, allocator);

            tool_other::send_json(JSON_CMD_VALUE_PUSH, tool_json::doc_to_json(doc));
        }

        if(site_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
        {
            log_info("收到web的删除卡命令,人卡考勤结束：卡id=%d，卡type=%d， stat_attendance=%d",
                     card_ptr->m_id, card_ptr->m_type, mine_tool_ptr->m_stat_attendance);
        }
    }

    /**
     * @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;
        }

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

        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(tool_other::type_id_to_u64(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;

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

                //检查井下是否超员--是否需要取消
                CMineCardManager::instance()->OnPersonUp(card_ptr);

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

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

        //升井json发给web
        if(datas.Size() > 0)
        {
            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, datas, allocator);

            tool_other::send_json(JSON_CMD_VALUE_PUSH, tool_json::doc_to_json(doc));
        }
    }

private:
    ///升井json
    static void to_json_card_up_one(std::shared_ptr<card_location_base> card_ptr,
                                       rapidjson::Value& out_datas, rapidjson::Document::AllocatorType& allocator)
    {
        auto site_area_ptr = card_ptr->get_site_area();
        if(!card_ptr->m_display || !site_area_ptr || site_area_ptr->is_invalid())
        {
            return;
        }

        auto mine_tool_ptr = card_ptr->get_mine_tool();

        rapidjson::Value data(rapidjson::kArrayType);
        //卡号
        std::string id = tool_other::type_id_to_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::elapse_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);


        out_datas.PushBack(data, allocator);
    }
};

#endif // MODULE_ATTENDANCE_PERSON_H