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<AIMInfo> 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<AIMInfo> 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<AIMInfo> 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<ConfigTerm> 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 auto t = CTL::ByteArray::Conversion<ConfigTerm>(packet.AdditionalData);
        CTL::AutoDestruct<ConfigTerm> autoDestruct(t);
        if (t) {
            const auto TMac = CTL::String(t->macChkStr);
            if (TMac == Setting->MacAddr) {
                const auto IP_t = Setting->IP;
                const auto GW_t = Setting->TermIPGw;
                const auto Nm_t = Setting->TermIPNm;
                const auto IDS = CTL::String(t->termIDnVerStr);
                if (!IDS.empty()) {
                    const int ID = IDS.to_int();
                    Setting->ID = ID;
                }
                const auto ServerIP = CTL::String(t->servIPAddrStr);
                if (!ServerIP.empty()) {
                    Setting->ServerIP = ServerIP;
                }
                const auto ServerPort = CTL::String(t->servCmdPortStr);
                if (!ServerPort.empty()) {
                     Setting->ServerPort = ServerPort.to_int();
                }
                const auto Port = CTL::String(t->termCmdPortStr);
                if (!Port.empty()) {
                    Setting->OrderPort = Port.to_int();
                }
                const auto DataPort = CTL::String(t->termStmPortStr);
                if (!DataPort.empty()) {
                       Setting->StreamPort = DataPort.to_int();
                }
                const auto WorkN = CTL::String(t->workModeStr);
                if (!WorkN.empty()) {
                    Setting->WorkingMode = WorkN.to_int();
                }
                const auto number = CTL::String(t->termTypeStr);
                if (!number.empty()) {
                    Setting->TermNumber = number.to_int();
                }
                const auto Flag = CTL::String(t->dhcpFlagStr);
                if (!Flag.empty()) {
                    Setting->DHCPFlag = Flag.to_int();
                }
                // -----------------------------------------------------------------
                const auto IP = CTL::String(t->termIPAddrStr);
                if (!IP.empty()) {
                    Setting->IP = IP;
                }
                const auto GW = CTL::String(t->termIPGwStr);
                if (!GW.empty()) {
                    Setting->TermIPGw = GW;
                }
                const auto NM = CTL::String(t->termIPNmStr);
                if (!NM.empty()) {
                    Setting->TermIPNm = NM;
                }
                // -----------------------------------------------------------------
                BS_Log::Log("Config::Save...");
                Config::Save();
#if IS_ARM
                if (IP_t != Setting->IP || GW_t != Setting->TermIPGw || Nm_t != Setting->TermIPNm){
                    BS_Log::Log("Config::SetNetWorkInfo IP:{} IPGw:{} IPNm: {}",IP.c_str(),
                        Setting->TermIPGw.c_str(),Setting->TermIPNm.c_str());
                    Config::SetNetWorkInfo(IP,Setting->TermIPGw,Setting->TermIPNm);
                }
#endif
                BS_Log::Log("Config::CloseService...");
                Config::CloseService();
                BS_Log::Log("CTL::Application::ReleaseLock...");
                CTL::Application::ReleaseLock();
                BS_Log::Log("std::terminate...");
                CTL::Thread::SleepMS(1000);
                std::terminate();
            }
        }
    }
};

#endif