server/module_service/module_call.h

#ifndef MODULE_CALL_H
#define MODULE_CALL_H

/**
 * @brief 呼叫模块
 * 用户通过WEB呼叫指定人员或者全部人员
 * @author 戴月腾
 * @date 2018-08-22
 */

#include <map>
#include <mutex>
#include <string>
#include <chrono>
#include <boost/thread.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <atomic>
#include "rapidjson/prettywriter.h"
#include"module_const.h"
#include"module_web.h"

/**
 * @brief 呼叫模块
 */
class module_call : public i_thread, public singleton_base<module_call>
{
private:
    friend class singleton_base<module_call>;
    module_call()
    {
    }

private:
    /**
     * @brief 呼叫卡的信息
     */
    struct call_card
    {
        /// 呼叫卡号 0为全员
        uint32_t cardid;
        /// 分站号  0为全员
        int stationid;
        /// 呼叫类型：一般1，紧急2  CALL_CARD_LEVEL
        int call_level_id;
        /// 呼叫时长，单位分钟
        int call_time_out;
        /// 呼叫开始时间
        std::chrono::system_clock::time_point call_time;
        /// 呼叫状态，正在呼叫、呼叫成功
        int call_state;
        ///呼叫人
        std::string user_name;
    };
    typedef std::shared_ptr<call_card>  call_card_ptr;
    typedef std::map<uint64_t,call_card_ptr>  call_card_map;

    /**
     * @brief 呼叫用户信息
     */
    struct call_user
    {
        ///呼叫人
        std::string user_name;
        ///呼叫类型 全员0, 定员1   CALL_CARD_TYPE
        int call_type_id;
        /// 呼叫等级：一般1，紧急2  CALL_CARD_LEVEL
        int call_level_id;
        /// 呼叫时长，单位分钟
        int call_time_out;
        /// 呼叫开始时间
        std::chrono::system_clock::time_point call_time;
        ///呼叫卡列表
        call_card_map cards;
    };
    typedef std::shared_ptr<call_user>  call_user_ptr;
    typedef std::map<std::string, call_user_ptr> call_user_map;

public:

    /**
     * @brief web发给采集：发起呼叫
     * @param node_data
     */
    void accept_call(const rapidjson::Document& node_data);

    /**
     * @brief web发给采集：取消呼叫
     * @param node_data
     */
    void accept_cancel(const rapidjson::Document& node_data);

    /**
     * @brief 登陆时，采集发送web：请求井下所有呼叫
     */
    std::string accept_login();

private:
    /**
     * @brief 采集回复web发起呼叫
     * @param arr
     */
    void response_accept_call(const std::vector<call_card_ptr> arr);

    /**
     * @brief 采集回复web：取消呼叫
     * @param node_data
     */
    void response_accept_cancel(const call_user_ptr user_ptr);



    void add_cards_to_user(int call_level, const rapidjson::Value& node_cards, call_user_ptr user_ptr);

    /**
     * @brief 线程函数
     */
    void run();

    void copy(const call_user_ptr src, call_user_ptr des)
    {
        des->call_level_id = src->call_level_id;
        des->call_time = src->call_time;
        des->call_time_out = src->call_time_out;
        des->call_type_id = src->call_type_id;
        des->user_name = src->user_name;
    }

    void copy(const call_card_ptr src, call_card_ptr des)
    {
        des->call_level_id = src->call_level_id;
        des->call_state = src->call_state;
        des->call_time = src->call_time;
        des->call_time_out = src->call_time_out;
        des->cardid = src->cardid;
        des->user_name = src->user_name;
        des->stationid = src->stationid;
    }

    void copy(const call_user_ptr src, call_card_ptr des)
    {
        des->call_level_id = src->call_level_id;
        //des->call_state = src->call_state;
        des->call_time = src->call_time;
        des->call_time_out = src->call_time_out;
        //des->cardid = src->cardid;
        des->user_name = src->user_name;
    }

    /**
     * @brief 获取用户下的所有呼叫卡
     * @param user_ptr
     * @param cardlist
     * @param out_data
     */
    void get_user_all_call_cards(call_user_ptr& user_ptr,
                        const std::unordered_map<uint64_t,std::shared_ptr<card_location_base>>& cardlist,
                        std::vector<call_card_ptr>& out_data);

    /**
     * @brief 获取所有的呼叫卡
     * @param user_map
     * @param cardlist
     * @param out_data
     */
    void get_all_call_cards(call_user_map& user_map,
                        const std::unordered_map<uint64_t,std::shared_ptr<card_location_base>>& cardlist,
                        std::vector<call_card_ptr>& out_data)
    {
        auto iter_m_map=user_map.begin();
        for(;iter_m_map!=user_map.end();++iter_m_map)
        {
            get_user_all_call_cards(iter_m_map->second, cardlist, out_data);

            if(iter_m_map->second->cards.empty())//没有卡了 删除呼叫用户
            {
                user_map.erase(iter_m_map--);
            }
        }
    }

    /**
     * @brief 获取所有的呼叫卡
     * @param out_data
     */
    void get_all_call_cards(std::vector<call_card_ptr>& out_data)
    {
        auto cardlist = card_list::instance()->m_map;

        {
            std::lock_guard<std::mutex> lock(_mutex);

            get_all_call_cards(_map, cardlist, out_data);
        }
    }

    /*
     * @brief
     * ["fjb", // 发起呼叫人
     * "0010000000001", // 呼叫的卡号
     * 103, // 分站号
     * 23431, // 发起呼叫时间
     * 0, //
     * 0 // 正在呼叫：2/结束呼叫/
     * ]
    */
    static void to_node_element(rapidjson::Value& out_elemet,
                                           const std::shared_ptr<call_card> card_ptr,
                                           rapidjson::Document::AllocatorType& allocator)
    {

        out_elemet.PushBack(rapidjson::StringRef(card_ptr->user_name.c_str()), allocator);
        out_elemet.PushBack(card_ptr->cardid, allocator);

        out_elemet.PushBack(card_ptr->stationid, allocator);
        out_elemet.PushBack(tool_time::to_ms(card_ptr->call_time), allocator);

        out_elemet.PushBack(0, allocator);
        out_elemet.PushBack(card_ptr->call_state, allocator);
    }

    static void to_node_array(rapidjson::Value& out_array,
                                                    const std::vector<std::shared_ptr<call_card>> cards,
                                                    rapidjson::Document::AllocatorType& allocator)
    {
        std::vector<std::shared_ptr<call_card>>::size_type i;

        for(i=0; i<cards.size(); i++)
        {
            rapidjson::Value node_card(rapidjson::kArrayType);

            to_node_element(node_card, cards[i], allocator);

            out_array.PushBack(node_card, allocator);
        }
    }

    /**
     * @brief  生成所有呼叫卡的json
     * @param cards
     * @return
     */
    std::string to_call_card_list_json(std::vector<call_card_ptr> cards);

//    /**
//     * @brief 获取取消用户的信息，主要包括用户下要取消呼叫的卡信息
//     * @param user_ptr
//     * @param node_cards
//     * @param result_user_ptr
//     */
//    void get_cancel_user_info(const call_user_ptr user_ptr,
//                              const rapidjson::Value& node_cards, call_user_ptr& result_user_ptr);

//    /**
//     * @brief 根据卡id在用户下查找是否有此卡
//     * @param user_ptr
//     * @param cardid
//     * @param card_ptr
//     * @return
//     */
//    bool find_card(const call_user_ptr user_ptr, const uint64_t cardid, call_card_ptr& card_ptr)
//    {
//        auto it = user_ptr->cards.find(cardid);
//        if(it!=user_ptr->cards.end())
//        {
//            card_ptr = it->second;
//            return true;
//        }

//        return false;
//    }

private:
    /// 呼叫用户列表
    call_user_map _map;
};


#endif // MODULE_CALL_H