RRJClient/Core/tcpclient.cpp

#include "tcpclient.h"
#include "Core/updatecontroller.h"
#include "externalexecuter.h"

#include <QDir>

TCPClient::TCPClient(QObject *parent) :
    QObject(parent)
{

}

void TCPClient::Initialize(UpdateController *updateController,
                           RecognizeSystem *recognize,
                           ExternalExecuter *externalExecuter)
{
    this->updateController = updateController;
    this->recognizeSystem = recognize;
    this->externalExecuter = externalExecuter;

    emit onSendDebugLog(Tools::GetTime() + " Client started");
}

void TCPClient::SetConnect(ServerSettings *serverSettings)
{
    socket = new QTcpSocket(this);

    connect(socket,&QTcpSocket::readyRead,this,&TCPClient::onReadyRead);
    connect(socket,&QTcpSocket::disconnected,this,&TCPClient::SetDisconnect);

    socket->connectToHost(serverSettings->Address,serverSettings->Port.toShort());
    emit onSendDebugLog("Try connect...");

    recognizeSystem->SetSocket(socket);
    socket->waitForReadyRead();

    if(socket->state() != QTcpSocket::ConnectedState){
        emit onSendDebugLog("Connect invalid");
        return;
    }else{
        emit onSendDebugLog("Connect complete");
    }
}

void TCPClient::SendClientAutorization()
{
    QDataStream stream(socket);
    stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);

    QFile file(tempName);
    file.open(QIODevice::ReadOnly);

    QByteArray array = file.readAll();
    stream << PacketType::TYPE_XMLANSWER;
    stream << array;
    socket->waitForBytesWritten();
}

void TCPClient::SetDisconnect()
{
    socket->disconnect();
    emit onSendDebugLog("Server disabled");
}

void TCPClient::WaitWrites()
{
    socket->waitForBytesWritten();
}

QTcpSocket *TCPClient::GetSocket()
{
    return socket;
}

void TCPClient::MessageEntered(QString message)
{
    QDataStream stream(socket);
    QByteArray data;
    stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);

    if(!message.isEmpty() && socket->state() == QTcpSocket::ConnectedState){

        socket->waitForBytesWritten();

        if(message == "check")
        {
            stream << PacketType::TYPE_COMMAND;
            stream << message;
            socket->waitForBytesWritten();

            updateController->SendFile(stream);
            emit onSendDebugLog(Tools::GetTime() + " Local checkFile sended");
            WaitWrites();
            socket->readyRead();
        }
        else if(message == "update"){
            emit onSendDebugLog("Update started");
            stream << PacketType::TYPE_COMMAND;
            stream << message;
            socket->waitForBytesWritten();
        }
        else if(message == "run"){
            externalExecuter->CallApp();
        }
    }else{
        emit onSendDebugLog("WRONG SOCKET AFTER ENTERED");
    }
}

void TCPClient::onReadyRead()
{
    if(!socket){
        emit onSendDebugLog("WRONG SOCKET");
        return;
    }

    recognizeSystem->Recognize();
}

TCPClient::~TCPClient()
{

}