resistancemonitor/Cpp/DataServices/LNHandle.h

#pragma once
#include <ProtocolHandler.h>
#include <ODBC/DBConnectPool.h>
#include <rapidjson/document.h>
#include <rapidjson/stringbuffer.h>
#include <rapidjson/reader.h>
#include <rapidjson/writer.h>
#include <string>
#include <vector>
#include <map>
#include "LNContext.h"
#include "AlarmDefine.h"

#define ROW_ARRAY_SIZE 50

typedef struct tagResistance
{
	char imei[50];
	//TIMESTAMP_STRUCT time;
	char  time[24];
    uint8_t index;
	int data0;
	int data1;
	int data2;
}RESISTANCE, *LPRESISTANCE;

struct tagHandlePack
{
private:
	~tagHandlePack() {};
public:
	LPBYTE pPack;
	int nPackLen;
	SOCKADDR psa = { 0 };
	CLNContext* pClientContext = nullptr;
	tagHandlePack(LPBYTE a, int b, SOCKADDR* c, CClientContext* d)
	{
		pPack = new BYTE[b];
		nPackLen = b;
		memcpy(pPack, a, b);
		if (c) memcpy(&psa, c, sizeof(SOCKADDR));
		if (d) pClientContext = (CLNContext*)d->GetSharedPointer(); //引用
	}
	void join()
	{
		if (pPack) delete[] pPack;
		nPackLen = 0;
		if (pClientContext) pClientContext->ReleaseSharedPointer(); //释放
		delete this;
	}
};

class CLNHandle
    :public CProtocolHandler
{
public:
    CLNHandle();
    virtual ~CLNHandle();

    virtual BOOL HandlePack(LPBYTE pPack, int nPackLen, SOCKADDR* psa, void* pClientContext = NULL) override;

	virtual BOOL ProcessPack(LPBYTE pPack, int nPackLen, SOCKADDR* psa, CLNContext* pClientContext);

	//发送升级需求给设备
	static int    SendUpdateToDevice(const char* imei, string remote_addr, string type);
	//发送请求实时数据给设备
	static int	  SendMsgToDevice(const char* imei);

	BOOL	SendTimeAckToAllDevice();

protected:
	BOOL	HandlePingPack(const rapidjson::Document& doc, const char* imei,  const SOCKADDR* psa, CLNContext* pClientContext = NULL);

	BOOL	HandlePushMsg(const rapidjson::Document& doc, const char* imei, const SOCKADDR* psa, CLNContext* pClientContext, LPBYTE pPack, int nPackLen);
	//传入空指针, 外面需要释放
	uint32_t GeneralResistPack(const string& momp, const int num, 
		const std::vector<int>& vctData0, const std::vector<int>& vctData1, const std::vector<int>& vctData2, 
		const std::vector<bool>& vctResult, const CTime& atime, uint8_t** pack, int* len);
	uint32_t GeneralResistPack(const string& momp, int data0, int data1, int data2, string str_time, uint8_t** pack, int* len);
	uint32_t GeneralTempPack(const string& momp, int temp, int Humi, time_t utime_t, uint8_t** pack, int* len);

	BOOL	HandlePushInfo(const rapidjson::Document& doc, const char* imei, const SOCKADDR* psa, CLNContext* pClientContext = NULL);

	BOOL	HandleInfoAck(const rapidjson::Document& doc, const char* imei, const SOCKADDR* psa, CLNContext* pClientContext = NULL);

	BOOL	HanldeTime(const rapidjson::Document& doc, const char* imei, const SOCKADDR* psa, CLNContext* pClientContext = NULL);

	BOOL	HandlePushOnline(const rapidjson::Document& doc, const char* imei, const SOCKADDR* psa, CLNContext* pClientContext, LPBYTE pPack, int nPackLen);

    //Web 客户端发送 tcp
    BOOL    HandleUpdate(const rapidjson::Document& doc, const char* imei, const SOCKADDR* psa, CLNContext* pClientContext = NULL);
    //Client
	BOOL    HandleUpdateAck(const rapidjson::Document& doc, LPBYTE pPack, int nPackLen, const char* imei, const SOCKADDR* psa, CLNContext* pClientContext = NULL);
    //get onlineDevice
    BOOL    HandleOnlineDevice(const rapidjson::Document& doc, const char* imei, const SOCKADDR* psa, CLNContext* pClientContext = NULL);
	BOOL    HandleOnlineDeviceNew(const SOCKADDR* psa, CLNContext* pClientContext = NULL);

	BOOL	HandleQueryMsgAck(const rapidjson::Document& doc, const char* imei, const SOCKADDR* psa, CLNContext* pClientContext = NULL);

    //设备升级
    BOOL    HandleUpdateInit(const rapidjson::Document& doc, const char* imei, const SOCKADDR* psa, CLNContext* pClientContext = NULL);
    //请求数据
    BOOL    HandleUpdateSeq(const rapidjson::Document& doc, const char* imei, const SOCKADDR* psa, CLNContext* pClientContext = NULL);

    BOOL    HandleUpdateOk(const rapidjson::Document& doc, const char* imei, const SOCKADDR* psa, CLNContext* pClientContext = NULL);
	//设备升级 end

private:

	static string		m_strUpgradeRemoteAddr;

	uint32_t	convertStrToArray(const string& str, std::vector<CString>& lst);

	static inline uint32_t	convertStrToArray(const string& str, std::vector<int>& lst)
	{
		// string->char *
		char* s_input = (char*)str.c_str();
		const char* split = ",";
		// 以逗号为分隔符拆分字符串
		char* p = strtok(s_input, split);

		int i = 0;
		while (p != NULL)
		{
			if (i < lst.capacity())
			{
				int l = strlen(p);
				if (l > 4)
					lst[i++] = strtol(p, NULL, 16) - 0x800000;
				else if (l == 4)
					lst[i++] = strtol(p, NULL, 16) - 0x8000;
			}
			p = strtok(NULL, split);
		}
		return i;
	}
	uint32_t	convertStrToArraytest(const string& str, std::vector<int>& lst);
	//2020年6月22日09:30:04 新增压缩
	uint32_t    compressArray(std::vector<CString>& vct1, std::vector<CString>& vct2, std::vector<CString>& vct3, uint32_t len, std::vector<bool>& result);


	static inline uint32_t compressArrayNew(IN std::vector<int>& vct1, IN std::vector<int>& vct2, IN std::vector<int>& vct3, OUT uint32_t len, std::vector<bool>& result,
		IN __time64_t tmStart, OUT tagSecondStatInfo& tSS1, OUT tagSecondStatInfo& tSS2, OUT tagSecondStatInfo& tSS3)
	{
		if (len == 0) return 0;
		int newlen = len;
		int per = 1000 / len;
		for (int i = 0; i < len; i++)
		{
			const auto a = vct1[i];
			const auto b = vct2[i];
			const auto c = vct3[i];

			if (a < -INVLID_VAL || a > INVLID_VAL)
			{
				result[i] = false;
				vct1[i] = INVLID_VAL;
			}
			if (b < -INVLID_VAL || b > INVLID_VAL)
			{
				result[i] = false;
				vct2[i] = INVLID_VAL;
			}
			if (c < -INVLID_VAL || c > INVLID_VAL)
			{
				result[i] = false;
				vct3[i] = INVLID_VAL;
			}
			if (result[i] == false)
			{
				newlen--;
				continue;
			}

			if (tSS1.first_val == INT_MIN) tSS1.first_val = a;			//存储第一个值
			if (tSS2.first_val == INT_MIN) tSS2.first_val = b;
			if (tSS3.first_val == INT_MIN) tSS3.first_val = c;

			if (a > tSS1.max_val)
			{
				tSS1.max_val = a;
				tSS1.max_time = tmStart + i * per;
			}
			if (b > tSS2.max_val)
			{
				tSS2.max_val = b;
				tSS2.max_time = tmStart + i * per;
			}
			if (c > tSS3.max_val)
			{
				tSS3.max_val = c;
				tSS3.max_time = tmStart + i * per;
			}

			if (a < tSS1.min_val)
			{
				tSS1.min_val = a;
				tSS1.min_time = tmStart + i * per;
			}
			if (b < tSS2.min_val)
			{
				tSS2.min_val = b;
				tSS2.min_time = tmStart + i * per;
			}
			if (c < tSS3.min_val)
			{
				tSS3.min_val = c;
				tSS3.min_time = tmStart + i * per;
			}

			tSS1.sum_val += a;
			tSS1.cout++;
			tSS1.end_val = a;

			tSS2.sum_val += b;
			tSS2.cout++;
			tSS2.end_val = b;

			tSS3.sum_val += c;
			tSS3.cout++;
			tSS3.end_val = c;
		}
		if (tSS1.cout) tSS1.dif_val = abs(tSS1.max_val - tSS1.min_val);
		if (tSS2.cout) tSS2.dif_val = abs(tSS2.max_val - tSS2.min_val);
		if (tSS3.cout) tSS3.dif_val = abs(tSS3.max_val - tSS3.min_val);

		//无波动 存第一个值
		//TRACE("%s\r\n", fmt::format("dif 1:{} 2:{} 3:{}", tSS1.dif_val, tSS2.dif_val, tSS3.dif_val).c_str());
		if (tSS1.dif_val < 100 && tSS2.dif_val < 100 && tSS3.dif_val < 100)
		{
			tSS1.cout = 1;
			tSS2.cout = 1;
			tSS3.cout = 1;
			bool bVal = true;
			for (int i = 0; i < len; i++)
			{
				if (result[i])
				{
					result[i] = bVal;
					bVal = false;
				}
			}
			return 1;
		}

		return newlen;
	}

	static inline uint32_t   compressArray(std::vector<int>& vct1, std::vector<int>& vct2, std::vector<int>& vct3, uint32_t len, std::vector<bool>& result)
	{
		int newlen = len;
		size_t i = 0;
		for (i; i < 2; i++)
		{
			if (abs(vct1[i]) > INVLID_VAL || abs(vct2[i]) > INVLID_VAL || abs(vct3[i]) > INVLID_VAL)
			{
				result[i] = false;
				newlen--;
			}
		}

		for (i; i < len; i++)
		{
			if (vct1[i - 2] == vct1[i - 1] && vct1[i - 1] == vct1[i] &&
				vct2[i - 2] == vct2[i - 1] && vct2[i - 1] == vct2[i] &&
				vct3[i - 2] == vct3[i - 1] && vct3[i - 1] == vct3[i])
			{
				result[i - 1] = false;
				newlen--;
			}
			else if (abs(vct1[i - 1]) > INVLID_VAL || abs(vct2[i - 1] > INVLID_VAL || abs(vct3[i - 1]) > INVLID_VAL))
			{
				result[i - 1] = false;
				newlen--;
			}
		}
		if (abs(vct1[i - 1]) > INVLID_VAL || abs(vct2[i - 1] > INVLID_VAL || abs(vct3[i - 1]) > INVLID_VAL))
		{
			result[i - 1] = false;
			newlen--;
		}

		return newlen;
	}

	static std::map<CString, COleDateTime> m_mapIMEI_time0;

	static std::map<CString, COleDateTime> m_mapIMEI_time3;

	static std::map<CString, COleDateTime> m_mapIMEI_time6;

	static std::map<CString, COleDateTime> m_mapIMEI_temp;

	std::map<string, time_t> m_mapTempHumi;  //温湿度1分钟上送一次

	//缓冲
	std::list<tagHandlePack*> m_lst;
	std::mutex m_mtx;
	std::thread* m_pThread = nullptr;
	static void ThreadForHandle(DWORD_PTR);
	bool m_bWork = false;
};