myvtm/Module/mod_DeviceControl/mod_DeviceControl.h

#ifndef _MOD_DEVICECONTROL_H
#define _MOD_DEVICECONTROL_H

#pragma once

#include "modVer.h"
#include "SpTest.h"
#include "DeviceControlFSM.h"
#include "DevEntityCommBase.hpp"
#include "TerminalInfoQueryConn.h"

// to get mac address
#include <string>
#include <vector>

#ifdef RVC_OS_WIN

#include <Winsock2.h>
#include <WS2tcpip.h>
#include <Iphlpapi.h>

#endif // RVC_OS_WIN

#pragma warning( disable : 4996 )

#define MACSESION 6

using namespace DeviceControl;

class CDeviceControlEntity;

class CDeviceControlServerSession: public DeviceControlService_ServerSessionBase
{
public:
	CDeviceControlServerSession(CDeviceControlEntity *pEntity):m_pEntity(pEntity){}
	virtual ~CDeviceControlServerSession(){}
	virtual void Handle_USB(SpReqAnsContext<DeviceControlService_USB_Req, DeviceControlService_USB_Ans>::Pointer ctx);
	virtual void Handle_GetUkeyID(SpReqAnsContext<DeviceControlService_GetUkeyID_Req, DeviceControlService_GetUkeyID_Ans>::Pointer ctx);
	virtual void Handle_InitToken(SpReqAnsContext<DeviceControlService_InitToken_Req, DeviceControlService_InitToken_Ans>::Pointer ctx);
	virtual void Handle_QueryUSBStatus(SpReqAnsContext<DeviceControlService_QueryUSBStatus_Req, DeviceControlService_QueryUSBStatus_Ans>::Pointer ctx);
	virtual void Handle_QueryHardwareInfo(SpReqAnsContext<DeviceControlService_QueryHardwareInfo_Req, DeviceControlService_QueryHardwareInfo_Ans>::Pointer ctx);
	virtual void Handle_ReadCenterConfigStr(SpReqAnsContext<DeviceControlService_ReadCenterConfigStr_Req, DeviceControlService_ReadCenterConfigStr_Ans>::Pointer ctx);
	virtual void Handle_ReadConfigValue(SpReqAnsContext<DeviceControlService_ReadConfigValue_Req, DeviceControlService_ReadConfigValue_Ans>::Pointer ctx);
	virtual void Handle_GetDevInfo(SpReqAnsContext<DeviceControlService_GetDevInfo_Req, DeviceControlService_GetDevInfo_Ans>::Pointer ctx);
	virtual void Handle_TestConnectivity(SpReqAnsContext<DeviceControlService_TestConnectivity_Req, DeviceControlService_TestConnectivity_Ans>::Pointer ctx);
	virtual void Handle_DeployTerminal(SpReqAnsContext<DeviceControlService_DeployTerminal_Req, DeviceControlService_DeployTerminal_Ans>::Pointer ctx);

private:
	CDeviceControlEntity *m_pEntity;
};

class CDeviceControlEntity : public CDevAdptEntityBase
{
public:
	CDeviceControlEntity():m_ServerConn(nullptr){ }
	virtual ~CDeviceControlEntity(){
		if (m_ServerConn) {
			if(m_ServerConn->IsConnectionOK()) {
				m_ServerConn->Close();
			}
			delete m_ServerConn;
			m_ServerConn = nullptr;
		}
	}
	virtual const char *GetEntityName() const { return "DeviceControl"; }

    const char* GetEntityVersion() const { return MODULE_VERSION_FULL; }

    ON_ENTITYT_TEST()

	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs,CSmartPointer<ITransactionContext> pTransactionContext) 
	{
		LOG_FUNCTION();
		ErrorCodeEnum rt = m_fsm.Init(this);
		pTransactionContext->SendAnswer(rt);
	}


    static void PrintTerminalRegistInfo(const TerminalRegistRet* info)
    {
        Dbg("TerminalNo: %s", info->TerminalNo);
        Dbg("DeviceNo: %s", info->DeviceNo);
        Dbg("OutletNo: %s", info->OutletNo);
        Dbg("Initializer: %s", info->Initializer);
        Dbg("PadDeviceID: %s", info->PadDeviceID);
        Dbg("MachineType: %s", info->MachineType);
        Dbg("MachineVersion: %s", info->MachineVersion);
        Dbg("Sites: %s", info->Sites);
        Dbg("EnrolAddr: %s", info->EnrolAddr);
        Dbg("Editor: %s", info->Editor);
        Dbg("State: %c", info->State);
        Dbg("PublicKey: %s", info->PublicKey);
        Dbg("FingerPrint: %s", info->FingerPrint);
    }


	virtual void OnPrePause(CSmartPointer<ITransactionContext> pTransactionContext)
	{
		//QueryHardwareInfo(NULL);
		if (!m_ServerConn) {
			m_ServerConn = new CTerminalInfoQuery(this);
		}
		m_ServerConn->ConnectServer("55.14.131.137", 1050);
		if (m_ServerConn->IsConnectionOK()) {
			TerminalRegistRet info;
			m_ServerConn->GetTerminalInfo("7555980028", &info);
			PrintTerminalRegistInfo(&info);
		}

		pTransactionContext->SendAnswer(Error_Succeed);
	}
	virtual void OnPreContinue(CSmartPointer<ITransactionContext> pTransactionContext)
	{
		if (m_ServerConn) {
            if (m_ServerConn->IsConnectionOK()) {
                m_ServerConn->Close();
            }
            delete m_ServerConn;
            m_ServerConn = nullptr;
		}
		pTransactionContext->SendAnswer(Error_Succeed);
	}
	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause,CSmartPointer<ITransactionContext> pTransactionContext)
	{
		m_fsm.OnExit();
		pTransactionContext->SendAnswer(Error_Succeed);
	}

	virtual CServerSessionBase* OnNewSession(const char*,const char*)
	{
		return new CDeviceControlServerSession(this);
	}

	void USB(SpReqAnsContext<DeviceControlService_USB_Req, DeviceControlService_USB_Ans>::Pointer ctx)
	{
		USBEvent *pEvt = new USBEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}

	void GetUkeyID(SpReqAnsContext<DeviceControlService_GetUkeyID_Req, DeviceControlService_GetUkeyID_Ans>::Pointer ctx)
	{
		GetUkeyIDEvent *pEvt = new GetUkeyIDEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}

	void InitToken(SpReqAnsContext<DeviceControlService_InitToken_Req, DeviceControlService_InitToken_Ans>::Pointer ctx)
	{
		InitTokenEvent *pEvt = new InitTokenEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}

	void QueryUSBStatus(SpReqAnsContext<DeviceControlService_QueryUSBStatus_Req, DeviceControlService_QueryUSBStatus_Ans>::Pointer ctx)
	{
		QueryUSBEvent *pEvt = new QueryUSBEvent();
		pEvt->ctx = ctx;
		m_fsm.PostEventFIFO(pEvt);
	}

	void QueryHardwareInfo(SpReqAnsContext<DeviceControlService_QueryHardwareInfo_Req, DeviceControlService_QueryHardwareInfo_Ans>::Pointer ctx);
	void ReadCenterConfigStr(SpReqAnsContext<DeviceControlService_ReadCenterConfigStr_Req, DeviceControlService_ReadCenterConfigStr_Ans>::Pointer ctx);

	void ReadConfigValue(SpReqAnsContext<DeviceControlService_ReadConfigValue_Req, DeviceControlService_ReadConfigValue_Ans>::Pointer ctx);

	void GetDevInfo(SpReqAnsContext<DeviceControlService_GetDevInfo_Req, DeviceControlService_GetDevInfo_Ans>::Pointer ctx)
	{
		ctx->Answer(Error_NotImpl);
	}

    void TestConnectivity(SpReqAnsContext<DeviceControlService_TestConnectivity_Req, DeviceControlService_TestConnectivity_Ans>::Pointer ctx);

    void DeployTerminal(SpReqAnsContext<DeviceControlService_DeployTerminal_Req, DeviceControlService_DeployTerminal_Ans>::Pointer ctx);


	void OnSelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext)
	{
		m_fsm.SelfTest(eTestType,pTransactionContext);
	}

	virtual bool IsService()const{return true;}
	virtual bool IsMultiThread()const{return true;}
private:
	std::pair<ErrorCodeEnum, CSimpleStringA> __ReadCenterConfigStr(CSimpleStringA key, CSimpleStringA entityName);
private:
	CDeviceControlFSM m_fsm;
	CTerminalInfoQuery* m_ServerConn;
};

#endif //_MOD_DEVICECONTROL_H