Distribution_Service/Server/PortService/R_Order_AA.h

#ifndef DISTRIBUTION_SERVICE_R_ORDER_AA_H
#define DISTRIBUTION_SERVICE_R_ORDER_AA_H

#include "DataPacket.h"
#include "ByteTool.h"
#include "CCApplication.h"
#include "ConnectionService.h"
#include "../Configuration/BS_Log.h"
#include "Terminal/Terminal.h"
#include "TaskModel/Transmitter.h"

class R_Order_AA {
public:
    static void Function(const DataPacket& packet){
        const auto N = packet.FunNumber.get();
        const auto hex = APPTool::GetHX(N);
        const auto str = CC::format("RoutingAA::Function(%s)", hex.c_str());
        BS_Log::Log(str);
    }
    static void Function_0x01(const DataPacket& packet) {
        const auto ID = APPTool::GetInt(packet.Parameter2, packet.Parameter3);
        const auto Term = Terminal::getData(ID);
        int Vol = 0;
        if (Term) {
            Term->Heartbeat++;
            if (Term->Status == 0) {
                Term->Status = 1;
                BS_Log::Log("Function_0x01 TermID: {} is ONLINE", ID);
            }
            Term->IP = packet.AimIP;
            Term->Port = packet.AimPort;
            Vol = Term->Vol;
        }
        else {
            const auto term = new Terminal();
            term->ID = ID;
            term->IP = packet.AimIP;
            term->Port = packet.AimPort;
            term->Status = 1;
            Vol = term->Vol;
            term->Heartbeat++;
            BS_Log::Log("Function_0x01 TermID: {} is New", ID);
            Terminal::addData(term);
        }
        const auto Setting = Config::getConfig();
        const auto Aim = new AIMInfo;
        CTL::AutoDestruct aim(Aim);
        Aim->IP = packet.AimIP;
        Aim->Port = packet.AimPort;
        Aim->Data = {0x66,0xAA,0x01,0x01,0x00,Vol,Setting->ServerID,Setting->ONLINEVol};
        Transmitter::Send_Massage(Aim);
    }
    static void Function_0x0B(const DataPacket& packet){
        const auto ID = APPTool::GetInt(packet.Parameter2, packet.Parameter3);
        const auto Term = Terminal::getData(ID);
        if (Term) {
            Term->Ver = packet.Parameter4;
            Term->StreamPort = packet.AimPort;
            const int D = APPTool::GetInt(packet.AdditionalData[12],packet.AdditionalData[13]);
            Term->TermDriveNumber = D;
        }
    }
    static void Function_0x80(const DataPacket& packet){
        const auto info = new AIMInfo();
        CTL::AutoDestruct autoDestruct(info);
        info->IP = packet.AimIP;
        info->Port = packet.AimPort;
        info->Data = packet.Buffer;
        bool F = Transmitter::Send_Massage(info);
    }
    static void Function_0xAA(const DataPacket& packet){
        const auto Setting = Config::getConfig();
        const uint8_t length = Setting->IP.length();
        const auto AimInfo = new AIMInfo();
        CTL::AutoDestruct autoDestruct(AimInfo);
        AimInfo->IP = packet.AimIP;
        AimInfo->Port = packet.AimPort;
        AimInfo->Data= {0x66,0xAA,0xAA,0x00,packet.Parameter2,packet.Parameter3,0x00,length};
        AimInfo->Data.append(Setting->IP);
        Transmitter::Send_Massage(AimInfo);
    }
    static void Function_0xC1(const DataPacket& packet){

    }
    static void Function_0xA4(const DataPacket& packet){

    }
    static void Function_0xA7(const DataPacket& packet){
        CTL::System::Println("Error: {} Str: {}",packet.Parameter1,packet.AdditionalData.toString().c_str());
    }
    static void Function_0xF2(const DataPacket& packet){
        const auto Setting = Config::getConfig();
        if (packet.Parameter1 == 0x00 && packet.Parameter2 == 0x00 && packet.Parameter3 == 0x45
            && packet.Parameter4 == 0x4E && packet.Parameter5 == 0x44) {
            const auto IDS = APPTool::GetBytes(Setting->ID);
            CTL::ByteArray data = {0x55,0xAA,0xF2,0x00,IDS[0],IDS[1],0x00,0x00};
            const auto t = Config::getThisInfo();
            CTL::AutoDestruct autoDestruct(t);
            CTL::ByteArray a;
            a.Conversion(t,sizeof(ConfigTerm));
            data.append(a);
            Config::groupBroadcast(data,22058);
        }
    }
    static void Function_0xF4(const DataPacket& packet){
        const auto Setting = Config::getConfig();
        const ConfigTerm* t = CTL::ByteArray::Conversion<ConfigTerm>(packet.AdditionalData);
        CTL::AutoDestruct autoDestruct(t);
        if (t) {
            const auto TMac = CTL::String(t->macStr);
            if (TMac == Setting->MacAddr) {
                const int ID = CTL::String(t->termIDnVerStr).to_int();
                const auto ServerIP = CTL::String(t->servIPAddrStr);
                const auto ServerPort = CTL::String(t->servCmdPortStr).to_int();
                const auto Port = CTL::String(t->termCmdPortStr).to_int();
                const auto DataPort = CTL::String(t->termStmPortStr).to_int();
                // -----------------------------------------------------------------
                const auto IP = CTL::String(t->termIPAddrStr);
                const auto GW = CTL::String(t->termIPGwStr);
                const auto NM = CTL::String(t->termIPNmStr);
                // -----------------------------------------------------------------
                Setting->ID = ID;
                Setting->ServerIP = ServerIP;
                Setting->ServerPort = ServerPort;
                Setting->OrderPort = Port;
                Setting->StreamPort = DataPort;
                Setting->IP = IP;
#if IS_ARM
                Config::SetNetWorkInfo(IP,GW,NM);
#endif
                Config::Save();
                Config::CloseService();
                CTL::Application::ReleaseLock();
                CTL::Thread::SleepMS(1000);
                std::terminate();
            }
        }
    }
};

#endif