server/common_tool.h

#ifndef COMMON_TOOL_H
#define COMMON_TOOL_H

#include"common.h"
#include"log.h"
#include"card.h"
#include<chrono>
#include<string>
#include<sys/time.h>
#include "db_api/CDBConnPool.h"
#include "websocket/wsClientMgr.h"

class tool_time
{
public:
    static uint32_t elapse_seconds(std::chrono::system_clock::time_point &start)
    {
        return static_cast<uint32_t>( std::chrono::duration_cast<std::chrono::seconds>
                (std::chrono::system_clock::now() - start).count() );
    }

    static uint64_t elapse_ms(std::chrono::system_clock::time_point &start)
    {
        return static_cast<uint64_t>( std::chrono::duration_cast<std::chrono::milliseconds>
                (std::chrono::system_clock::now() - start).count() );
    }

    static uint32_t now_to_seconds()
    {
        return static_cast<uint32_t>( std::chrono::duration_cast<std::chrono::seconds>
                (std::chrono::system_clock::now().time_since_epoch()).count() );
    }

    static uint64_t now_to_ms()
    {
        return static_cast<uint64_t>( std::chrono::duration_cast<std::chrono::milliseconds>
                (std::chrono::system_clock::now().time_since_epoch()).count() );
    }

    static uint64_t now_to_us()
    {
        return static_cast<uint64_t>( std::chrono::duration_cast<std::chrono::microseconds>
                (std::chrono::system_clock::now().time_since_epoch()).count() );
    }

    static uint64_t to_ms(const std::chrono::system_clock::time_point &time)
    {
        return static_cast<uint64_t>( std::chrono::duration_cast<std::chrono::milliseconds>
                (time.time_since_epoch()).count() );
    }

    static std::string to_str(const std::chrono::system_clock::time_point &time)
    {
        char _time[25] = {0};
        time_t tt = std::chrono::system_clock::to_time_t(time);
        struct tm local_time;
        localtime_r(&tt, &local_time);
        strftime(_time, 22, "%Y-%m-%d %H:%M:%S", &local_time);

        return std::string(_time);
    }

    //"%Y-%m-%d %H:%M:%S"
    static time_t to_time(std::string str)
    {
        time_t t_;
        tm tm_;
        strptime(str.c_str(), "%Y-%m-%d %H:%M:%S", &tm_); //将字符串转换为tm时间
        t_ = mktime(&tm_); //将tm时间转换为秒时间

        return t_;
    }

    ////"%d-%02d-%02d %02d:%02d:%02d.%03d"
    static std::chrono::system_clock::time_point to_time_ex(std::string str)
    {
        uint64_t pos = str.length()-3;

        time_t t_;
        tm tm_;
        strptime(str.substr(0,pos).c_str(), "%Y-%m-%d %H:%M:%S", &tm_); //将字符串转换为tm时间
        t_ = mktime(&tm_); //将tm时间转换为秒时间

        int milli = std::stoi(str.substr(pos));

        return std::chrono::system_clock::time_point(std::chrono::milliseconds(t_*1000 + milli));
    }

    //"%d-%02d-%02d %02d:%02d:%02d.%03d"
    static std::string to_str_ex(uint64_t ms)
    {
        int32_t mill = ms%1000;

        char _time[25] = {0};
        time_t tt = ms/1000;
        struct tm *local_time=localtime(&tt);
        //strftime(_time, 22, "%Y-%m-%d %H:%M:%S", local_time);
        sprintf(_time, "%d-%02d-%02d %02d:%02d:%02d.%03d", local_time->tm_year+1900,
                local_time->tm_mon+1, local_time->tm_mday, local_time->tm_hour,
                local_time->tm_min, local_time->tm_sec, mill);

        return std::string(_time);
    }

    //"%d-%02d-%02d %02d:%02d:%02d.%03d"
    static std::string to_str_ex(std::chrono::system_clock::time_point time)
    {
        return to_str_ex(to_ms(time));
    }

    static int elapse_seconds(time_t &start)
    {
        time_t now;
        time(&now);
        return static_cast<int>(std::difftime(now, start));
    }

    //"%Y-%m-%d %H:%M:%S"
    static std::string to_str(const std::time_t &time)
    {
        char _time[25] = {0};
        struct tm local_time;
        localtime_r(&time, &local_time);
        strftime(_time, 22, "%Y-%m-%d %H:%M:%S", &local_time);

        return std::string(_time);
    }
};

class tool_other
{
public:
    static void send_json(const std::string& cmd, const std::string& data)
    {
        std_debug("发送json: cmd=%s， data=%s\n", cmd.c_str(), data.c_str());
        log_info("发送json: cmd=%s， data=%s\n", cmd.c_str(), data.c_str());
        swsClientMgr.send(cmd, data);
    }

    static std::string to13str(std::string& str)
    {
        uint64_t tmp = std::stoull(str);
        char ss[20]={0};
        sprintf(ss, "%013ld", tmp);

        return std::string(ss);
    }

    static uint32_t id64_to_id(std::string& str)
    {
        return static_cast<uint32_t>(std::stoul(to13str(str).substr(3)));
    }

    static int id64_to_type(std::string& str)
    {
        return std::stoi(to13str(str).substr(0, 3));
    }
};


class tool_db
{
public:
    static void PushAsync(char* sql)
    {
        //std_debug("PushAsync记录到队列中:%s\n", sql);
        //log_info("PushAsync记录到队列中:%s\n", sql);

        if(!sDBConnPool.PushAsync(sql))
        {
            log_error( "PushAsync记录到队列中失败\n");
        }
    }

    static void save_attendance(const std::shared_ptr<card_location_base> card_ptr)
    {
        char sql[LENGTH_SQL] = {0};

        std::string call("add_att_staff");
        if(card_ptr->is_vehicle())//车卡
        {
            call="add_att_vehicle";
        }

        auto site_area_ptr = card_ptr->get_site_area();

        auto start = site_area_ptr->m_attendance_start_time;
        auto end = site_area_ptr->m_attendance_start_time;
        if(!site_area_ptr->is_attendance())//考勤结束时间
        {
            end = std::chrono::system_clock::time_point(std::chrono::milliseconds(card_ptr->m_time));
        }

        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(),
                card_list::to_id64_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);
    }
};

class tool_map
{
public:
    static bool try_get_value(sio::message::ptr& out_data,
                              const char* key, sio::message::ptr const& data)
    {
        auto map=data->get_map()[key];
        if(map && sio::message::flag_object == map->get_flag())
        {
            out_data = map;
            return true;
        }

        return false;
    }

    static bool try_get_value(int64_t& out_data, const char* key, sio::message::ptr const& data)
    {
        auto map=data->get_map()[key];
        if(map && sio::message::flag_integer == map->get_flag())
        {
            out_data = map->get_int();
            return true;
        }

        return false;
    }

    static bool try_get_value(uint32_t& out_data, const char* key, sio::message::ptr const& data)
    {
        auto map=data->get_map()[key];
        if(map && sio::message::flag_integer == map->get_flag())
        {
            out_data = static_cast<uint32_t>(map->get_int());
            return true;
        }

        return false;
    }

    static bool try_get_value(int& out_data, const char* key, sio::message::ptr const& data)
    {
        auto map=data->get_map()[key];
        if(map && sio::message::flag_integer == map->get_flag())
        {
            out_data = static_cast<int>(map->get_int());
            return true;
        }

        return false;
    }

    static bool try_get_value(std::string& out_data, const char* key, sio::message::ptr const& data)
    {
        auto map=data->get_map()[key];
        if(map && sio::message::flag_string == map->get_flag())
        {
            out_data = map->get_string();
            return true;
        }

        return false;
    }

    static bool try_get_value(double& out_data, const char* key, sio::message::ptr const& data)
    {
        auto map=data->get_map()[key];
        if(map && sio::message::flag_double == map->get_flag())
        {
            out_data = map->get_double();
            return true;
        }

        return false;
    }

    static bool try_get_value(std::vector<sio::message::ptr>& out_data,
                               const char* key, sio::message::ptr const& data)
    {
        auto map=data->get_map()[key];
        if(map && sio::message::flag_array == map->get_flag())
        {
            out_data = map->get_vector();
            return true;
        }

        return false;
    }
};

class tool_json
{
public:
    static void add_member(rapidjson::Value& out_data, const char* key, std::string value,
                              rapidjson::Document::AllocatorType& allocator)
    {
        rapidjson::Value name;
        name.SetString(key, allocator);

        rapidjson::Value data;
        data.SetString(value.c_str(), allocator);

        out_data.AddMember(name, data, allocator);
    }

    static void push_back(rapidjson::Value& out_data, std::string value,
                              rapidjson::Document::AllocatorType& allocator)
    {
        rapidjson::Value data;
        data.SetString(value.c_str(), allocator);

        out_data.PushBack(data, allocator);
    }

    static bool try_get_iter(const char* key, const rapidjson::Value& node,
                             rapidjson::Value::ConstMemberIterator& out_iter)
    {
        if(node.IsObject())
        {
            out_iter = node.FindMember(key);
            if(node.MemberEnd() == out_iter)
            {
                return false;
            }

            return true;
        }

        return false;
    }

    static bool try_get_value(int& d, const char* key, const rapidjson::Value& node)
    {
        rapidjson::Value::ConstMemberIterator iter;
        if(try_get_iter(key, node, iter))
        {
            if(iter->value.IsInt())
            {
                d = iter->value.GetInt();
                return true;
            }
        }

        return false;
    }

    static bool try_get_value(uint64_t& d, const char* key, const rapidjson::Value& node)
    {
        rapidjson::Value::ConstMemberIterator iter;
        if(try_get_iter(key, node, iter))
        {
            if(iter->value.IsUint64())
            {
                d = iter->value.GetUint64();
                return true;
            }
        }
        return false;
    }

    static bool try_get_value(double& d, const char* key, const rapidjson::Value& node)
    {
        rapidjson::Value::ConstMemberIterator iter;
        if(try_get_iter(key, node, iter))
        {
            if(iter->value.IsDouble())
            {
                d = iter->value.GetDouble();
                return true;
            }
        }
        return false;
    }

    static bool try_get_value(std::string& d, const char* key, const rapidjson::Value& node)
    {
        rapidjson::Value::ConstMemberIterator iter;
        if(try_get_iter(key, node, iter))
        {
            if(iter->value.IsString())
            {
                d = iter->value.GetString();
                return true;
            }
        }

        return false;
    }

    static int get_value(const char* key, const int& default_data, const rapidjson::Value& node)
    {
        rapidjson::Value::ConstMemberIterator iter;
        if(try_get_iter(key, node, iter))
        {
            if(iter->value.IsInt())
            {
                return  iter->value.GetInt();
            }
        }

        return default_data;
    }

    static std::string get_value(const char* key, const std::string& default_data, const rapidjson::Value& node)
    {
        rapidjson::Value::ConstMemberIterator iter;
        if(try_get_iter(key, node, iter))
        {
            if(iter->value.IsString())
            {
                return iter->value.GetString();
            }
        }

        return default_data;
    }

    static std::string doc_to_json(rapidjson::Document& doc)
    {
        rapidjson::StringBuffer sb;
        rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(sb);
        doc.Accept(writer);

        return sb.GetString();
    }
};

#endif // COMMON_TOOL_H