Merge branch 'new-init-behaviour' into DEV

# Conflicts:
#	InstructorsAndTrainees/connectorToServer/Core/sendsystem.cpp
#	InstructorsAndTrainees/connectorToServer/connectortoserver.cpp

InstructorsAndTrainees/connectorToServer/Core/sendsystem.cpp

@@ -30,18 +30,17 @@ void SendSystem::sendDisable()
     stream << data;
     socket->waitForBytesWritten();
 }
-/*
-void SendSystem::sendXMLmsgGUItoServer(QByteArray array)
-{
-    qDebug() << "SendSystem" << QThread::currentThreadId();
-    QDataStream stream(socket);
-    stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);
 
-    stream << PacketType::TYPE_XMLANSWER;
+//void SendSystem::sendXMLmsgGUItoServer(QByteArray array)
-    stream << array;
+//{
-    socket->waitForBytesWritten(6000);
+//    qDebug() << "SendSystem" << QThread::currentThreadId();
-}
+//    QDataStream stream(socket);
-*/
+//    stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);
+
+//    stream << PacketType::TYPE_XMLANSWER;
+//    stream << array;
+//    socket->waitForBytesWritten(6000);
+//}
 
 void SendSystem::sendFileBlock(QString path)
 {

InstructorsAndTrainees/connectorToServer/connectortoserver.cpp

@@ -12,7 +12,6 @@ ConnectorToServer::ConnectorToServer(QWidget* parentWidget, QObject *parent) :
     versionSelectWidget(nullptr),
     versionContainer(nullptr),
     notifyController(nullptr),
-    isLoggedIn(false),
     fl_GetedOfflineMessages(false)
 {
     initialize();
@@ -44,7 +43,6 @@ bool ConnectorToServer::authorizationInstructorLocal(QString login, QString pass
     autorization->Login = login;
     autorization->Password = password;
     autorization->TypeClient = TypeClientAutorization::TYPE_GUI;
-    isLoggedIn = true;
 
     QByteArray array = dataParser->createAuthMessage(autorization);
     emit sigSendAnswerToServer(array);
@@ -61,7 +59,6 @@ bool ConnectorToServer::deAuthorizationInstructorLocal(QString login)
 
     ClientDeAutorization *deAutorization = new ClientDeAutorization;
     deAutorization->Login = login;
-    isLoggedIn = false;
 
     QByteArray array = dataParser->createDeAuthMessage(deAutorization);
     emit sigSendAnswerToServer(array);
@@ -367,11 +364,6 @@ void ConnectorToServer::slot_AnswerQueryToDB_ListTrainees(QList<Trainee> listTra
         listUsers.append(trainee);
     }
     emit signal_reInitMessangerByUsers(listUsers);
-
-    if (isLoggedIn)
-    {
-        sendClientNotify(cmd_GetOfflineMessages);
-    }
 }
 
 void ConnectorToServer::slot_AnswerQueryToDB_ListComputers(QList<Computer> listComputers)

InstructorsAndTrainees/connectorToServer/connectortoserver.h

@@ -152,8 +152,6 @@ private:
     QByteArray listTaskAmmArray;
 
     ServerSettings serverSettings;
-    bool isLoggedIn;
-
     ServerAuthorization serverAuth;
 
     bool fl_GetedOfflineMessages;

ServerLMS/Data/PacketType.h

@@ -54,28 +54,38 @@ QString enumToString(T value);
 template<>
 inline QString enumToString(PacketType value) {
     switch(value) {
-        case PacketType::TYPE_NONE: return "TYPE_NONE";
+    case PacketType::TYPE_NONE: return "TYPE_NONE";
-        case PacketType::TYPE_UNITY: return "TYPE_UNITY";
+           case PacketType::TYPE_UNITY: return "TYPE_UNITY";
-        case PacketType::TYPE_FILE: return "TYPE_FILE";
+           case PacketType::TYPE_FILE: return "TYPE_FILE";
-        case PacketType::TYPE_COMMAND: return "TYPE_COMMAND";
+           case PacketType::TYPE_COMMAND: return "TYPE_COMMAND";
-        case PacketType::TYPE_FOLDER: return "TYPE_FOLDER";
+           case PacketType::TYPE_FOLDER: return "TYPE_FOLDER";
-        case PacketType::TYPE_DELETE: return "TYPE_DELETE";
+           case PacketType::TYPE_DELETE: return "TYPE_DELETE";
-        case PacketType::TYPE_FINISH: return "TYPE_FINISH";
+           case PacketType::TYPE_FINISH: return "TYPE_FINISH";
-        case PacketType::TYPE_NEEDUPDATE: return "TYPE_NEEDUPDATE";
+           case PacketType::TYPE_NEEDUPDATE: return "TYPE_NEEDUPDATE";
-        case PacketType::TYPE_XMLANSWER: return "TYPE_XMLANSWER";
+           case PacketType::TYPE_XMLANSWER: return "TYPE_XMLANSWER";
-        case PacketType::TYPE_QT: return "TYPE_QT";
+           case PacketType::TYPE_QT: return "TYPE_QT";
-        case PacketType::TYPE_DISABLE: return "TYPE_DISABLE";
+           case PacketType::TYPE_DISABLE: return "TYPE_DISABLE";
-        case PacketType::TYPE_UPDATE: return "TYPE_UPDATE";
+           case PacketType::TYPE_UPDATE: return "TYPE_UPDATE";
-        case PacketType::TYPE_CHECK_VERSION: return "TYPE_CHECK_VERSION";
+           case PacketType::TYPE_CHECK_VERSION: return "TYPE_CHECK_VERSION";
-        case PacketType::TYPE_FILESIZE: return "TYPE_FILESIZE";
+           case PacketType::TYPE_FILESIZE: return "TYPE_FILESIZE";
-        case PacketType::TYPE_BIGXML: return "TYPE_BIGXML";
+           case PacketType::TYPE_BIGXML: return "TYPE_BIGXML";
-        case PacketType::CHANGE_DATA_VERSION: return "CHANGE_DATA_VERSION";
+           case PacketType::CHANGE_DATA_VERSION: return "CHANGE_DATA_VERSION";
-        case PacketType::COPY_VERSION: return "COPY_VERSION";
+           case PacketType::COPY_VERSION: return "COPY_VERSION";
-        case PacketType::DELETE_DATA_VERSION: return "DELETE_DATA_VERSION";
+           case PacketType::DELETE_DATA_VERSION: return "DELETE_DATA_VERSION";
-        case PacketType::BUSY: return "BUSY";
+           case PacketType::BUSY: return "BUSY";
-        case PacketType::FREE: return "FREE";
+           case PacketType::FREE: return "FREE";
-        case PacketType::HASH_CALCULATE_START: return "HASH_CALCULATE_START";
+           case PacketType::HASH_CALCULATE_START: return "HASH_CALCULATE_START";
-        case PacketType::HASH_READY: return "HASH_READY";
+           case PacketType::HASH_READY: return "HASH_READY";
+           case PacketType::TYPE_XMLANSWER_MESSAGE_FOR_GUI: return "TYPE_XMLANSWER_MESSAGE_FOR_GUI";
+           case PacketType::TYPE_XMLANSWER_QUERY_DB__LIST_INSTRUCTORS: return "TYPE_XMLANSWER_QUERY_DB__LIST_INSTRUCTORS";
+           case PacketType::TYPE_XMLANSWER_QUERY_DB__LIST_GROUPS: return "TYPE_XMLANSWER_QUERY_DB__LIST_GROUPS";
+           case PacketType::TYPE_XMLANSWER_QUERY_DB__LIST_TRAINEES: return "TYPE_XMLANSWER_QUERY_DB__LIST_TRAINEES";
+           case PacketType::TYPE_XMLANSWER_QUERY_DB__LIST_COMPUTERS: return "TYPE_XMLANSWER_QUERY_DB__LIST_COMPUTERS";
+           case PacketType::TYPE_XMLANSWER_QUERY_DB__LIST_CLASSROOMS: return "TYPE_XMLANSWER_QUERY_DB__LIST_CLASSROOMS";
+           case PacketType::TYPE_XMLANSWER_QUERY_TASKS_AMM_OF_TRAINEE: return "TYPE_XMLANSWER_QUERY_TASKS_AMM_OF_TRAINEE";
+           case PacketType::TYPE_XMLANSWER_QUERY_TASKS_FIM_OF_TRAINEE: return "TYPE_XMLANSWER_QUERY_TASKS_FIM_OF_TRAINEE";
+           case PacketType::TYPE_XMLANSWER_QUERY_TASKS_XML_FIM: return "TYPE_XMLANSWER_QUERY_TASKS_XML_FIM";
+           case PacketType::TYPE_XMLANSWER_QUERY_TASKS_XML_AMM: return "TYPE_XMLANSWER_QUERY_TASKS_XML_AMM";
 
         default: return "Unknown";
     }

ServerLMS/Systems/processingsystem.cpp

@@ -523,7 +523,7 @@ void ProcessingSystem::processingClientNotify(ClientHandler *client, ClientNotif
     {//Клиент готов принять задания
         client->setReady(true);
         sendTaskListToUnity(client);
-        client->getSocket()->flush();
+        //client->getSocket()->flush();
     }
     else if(clientNotify.Code == commandStartTimerClient)
     {
@@ -572,6 +572,8 @@ void ProcessingSystem::processingClientNotify(ClientHandler *client, ClientNotif
     {
         chatSystem->sendOldMessages(client->getClient()->getId());
     }
+
+    Logger::instance().log(client->getClient()->getLogin() + " notifyCode " + clientNotify.Code,LogLevel::DEBUG);
 }
 
 void ProcessingSystem::setCurrentDataInfo(DataInfo *dataInfo)

ServerLMS/Systems/recognizesystem.cpp

@@ -48,19 +48,6 @@ void RecognizeSystem::recognize()
         {
             stream.startTransaction();
 
-            if(!isPackageTypeInited)        //первичная инициализация для типа клиента
-            {
-                char *read = new char[4];
-                stream.readRawData(read,4);
-
-                int numPackage = *((int*)read);
-                packetType = static_cast<PacketType>(numPackage);
-                packetTypeInit(packetType,client);
-
-                if(!stream.commitTransaction()) continue;
-                continue;
-            }
-
             if(client->getClientType() == TypeClientAutorization::TYPE_UNITY_CLIENT)
             {
                 char *read = new char[4];
@@ -81,7 +68,34 @@ void RecognizeSystem::recognize()
         }
 
         if (packetType != PacketType::TYPE_NONE)
-            Logger::instance().log("C: " + client->getLogin() + " RECEIVE pack " + enumToString(packetType),LogLevel::DEBUG);
+               {
+                   QString result = enumToString(packetType);
+                   Logger::instance().log(client->getLogin() +
+                                          " RECEIVE pack " +
+                                          result ,LogLevel::DEBUG);
+                   //секция на случай прихода неизвестного пакета
+                   if(result == "Unknown")
+                   {
+                           qDebug() << "  State:" << socket->state();
+                           qDebug() << "  Error:" << socket->error();
+                           qDebug() << "  Bytes to write:" << socket->bytesToWrite();
+                           qDebug() << "  Bytes available:" << socket->bytesAvailable();
+                       if(client->getTypeClient() == TypeClientAutorization::TYPE_UNITY_CLIENT)
+                       {
+                           data = socket->readAll();
+                       }
+                       else
+                       {
+                           stream.startTransaction();
+                           stream >> data;
+                       }
+                       QString dataText = QString::fromUtf8(data);
+                       Logger::instance().log(QString::number(packetType) + " Unknown text " + dataText);
+                       Logger::instance().log("Client error: " + client->getLogin(),LogLevel::ERROR);
+                       clientHandler->sendDisable();
+                       //mutex->unlock();
+                   }
+               }
 
         if (packetType == PacketType::TYPE_COMMAND) //TODO: надо переделать под какой то нормальный тип, который уже существует
         {
@@ -138,12 +152,11 @@ void RecognizeSystem::recognize()
                 socket->read(readBuffer,4);
                 fileSize = *((int*)readBuffer);
 
-                stream.commitTransaction();
+                //if(!stream.commitTransaction()) continue;
-                //if(!) continue;
                 //ПОЛУЧЕНИЕ САМОГО ФАЙЛА
                 Logger::instance().log("AfterRead size and path BytesAvailable: " + QString::number(socket->bytesAvailable()));
 
-                qint64 readSize = 65535;
+                qint64 readSize = readFileBlockSize;
                 forever
                 {
 
@@ -440,25 +453,6 @@ void RecognizeSystem::recognize()
     //mutex->unlock();
 }
 
-void RecognizeSystem::packetTypeInit(PacketType packet,Client *client)
-{
-    if(packet == PacketType::TYPE_QT)
-    {
-        client->setUnity(TypeClientAutorization::TYPE_QT_CLIENT);
-
-        qDebug() << "ConnectionType isUnity: " << client->getClientType();
-    }
-    else if (packet == PacketType::TYPE_UNITY)
-    {
-        client->setUnity(TypeClientAutorization::TYPE_UNITY_CLIENT);
-        //Фиксируем время входа Юнити-клиента
-    }
-
-     isPackageTypeInited = true;
-    Logger::instance().log("C: " + client->getLogin() + " send pack " + enumToString(packetType));
-    packetType = PacketType::TYPE_NONE;
-}
-
 bool RecognizeSystem::checkIsChangeable()
 {
     return updateController->getCurrentVersion()->getIsChangeable();

ServerLMS/Systems/recognizesystem.h

@@ -56,10 +56,7 @@ private:
     qint64 sizeReceiveData;
     qint64 fileSize;
     int countSend;
-    bool isPackageTypeInited;
-
     void packetTypeInit(PacketType packet,Client *client);
-    //void packetTypeInit(PacketType type);
 
     bool checkIsChangeable();    
 };

ServerLMS/Systems/sendsystem.cpp

@@ -61,7 +61,7 @@ void SendSystem::sendFileBlock(QString path)
     {
         while(!file.atEnd())
         {
-            QByteArray data = file.read(1025*250);
+            QByteArray data = file.read(sendFileBlockSize);
             stream << data;
             //socket->waitForBytesWritten(10);
 
@@ -78,35 +78,58 @@ void SendSystem::sendFileBlock(QString path)
 
 void SendSystem::sendFileBlockByteArray(QByteArray array, PacketType packetType)
 {
-    qDebug() << "sendFileBlockByteArray thread: " << QThread::currentThreadId();
     if(client->getClientType() == TypeClientAutorization::TYPE_QT_CLIENT ||
-       client->getClientType() == TypeClientAutorization::TYPE_GUI)
+           client->getClientType() == TypeClientAutorization::TYPE_GUI)
     {
         QDataStream stream(socket);
         stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);
 
-        fileSize = array.size();
+        quint64 size = array.size();
+        qint64 bytesSended = 0;
 
-        if(fileSize == 0){
+        if (size == 0)
-            Logger::instance().log(" WARNING! Zero size ",LogLevel::ERROR);
+        {
-            return;
+           Logger::instance().log(" WARNING! Zero size ",LogLevel::ERROR);
-        }
+                    return;
+         }
 
-        stream << packetType; //Отправляем тип блока
+         stream << packetType; //Отправляем тип блока
-        stream << fileSize;
+         stream << size;
-        stream << array;
+
+         while (size > 0)
+         {
+             QByteArray chunk = array.mid(bytesSended,sendFileBlockSize);
+             stream << chunk;
+
+             bytesSended += chunk.length();
+             size -= bytesSended;
+         }
     }
     else
     {
-        sendPacketType(packetType);
+         sendPacketType(packetType);
-        QByteArray message;
+         quint64 size = array.size();
-        int size = array.length();
+         qint64 bytesSended = 0;
-        message.append(reinterpret_cast<char*>(&size), sizeof(int));
+
-        socket->write(message);
+         if (size == 0)
-        socket->write(array);
+         {
+            Logger::instance().log(" WARNING! Zero size ",LogLevel::ERROR);
+                     return;
+         }
+
+         QByteArray message;
+         message.append(reinterpret_cast<char*>(&size), sizeof(int));
+         socket->write(message);
+
+         while (size > 0)
+         {
+             QByteArray chunk = array.mid(bytesSended,sendFileBlockSize);
+             quint64 bytesSended = socket->write(chunk);
+
+             size -= bytesSended;
+         }
+
     }
-
-
 }
 
 void SendSystem::sendVersion()
@@ -148,7 +171,7 @@ void SendSystem::sendFileBlockWithRename(QString path, QString newName)
 
     if(file.open(QFile::ReadOnly)){
         while(!file.atEnd()){
-            QByteArray data = file.read(1025*250);
+            QByteArray data = file.read(sendFileBlockSize);
             stream << data;
             socket->waitForBytesWritten();
             countSend++;

ServerLMS/Systems/tools.h

@@ -50,6 +50,11 @@ static const QString commandUpdateFilesClient = "update";
 static const QString commandGetTasks = "GETTASKS";
 static const QString commandeGetOfflineMessages = "GETOFFLINEMESSAGE";
 
+//static quint64 fileBlockSize = 1460;
+static quint64 sendFileBlockSize = 256000;
+static quint64 readFileBlockSize = 65535;
+//1025*250
+
 class Tools {
 public:
     static void printTime();

ServerLMS/clienthandler.cpp

@@ -56,12 +56,13 @@ void ClientHandler::initialize(int descriptor,ServerLMSWidget *serverWidget,
     connect(this,&ClientHandler::sigSendPacketType,sendSystem,&SendSystem::sendPacketType,Qt::AutoConnection);
     connect(this,&ClientHandler::sigSendStop,sendSystem,&SendSystem::sendStop,Qt::DirectConnection);
 
-    connect(socket,&QTcpSocket::readyRead,recognizeSystem,&RecognizeSystem::recognize,Qt::AutoConnection);
+    connect(socket,&QTcpSocket::readyRead,this,&ClientHandler::initClientType,Qt::AutoConnection);
-    connect(socket, &QTcpSocket::disconnected, this, &ClientHandler::sendDisable,Qt::AutoConnection);
+    initClientType();
 
     recognizeSystem->initialize(updateController,dataParser,serverWidget,sendSystem, this);
     sendSystem->setClient(client,socket);
     emit sigInitSender(dataParser,serverWidget->getMutex());
+
 }
 
 void ClientHandler::setClient(Client *value)
@@ -69,6 +70,30 @@ void ClientHandler::setClient(Client *value)
     client = value;
 }
 
+void ClientHandler::initClientType()
+{
+    QDataStream stream(socket);
+    stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);
+
+    while (socket->bytesAvailable() > 0)
+    {
+        stream.startTransaction();
+        char *read = new char[4];
+        stream.readRawData(read,4);
+
+        int numPackage = *((int*)read);
+        PacketType packetType = static_cast<PacketType>(numPackage);
+
+        if(!stream.commitTransaction()) continue;
+
+        packetTypeInit(packetType,client);
+
+        disconnect(socket,&QTcpSocket::readyRead,this,&ClientHandler::initClientType);
+        connect(socket,&QTcpSocket::readyRead,recognizeSystem,&RecognizeSystem::recognize,Qt::AutoConnection);
+        connect(socket, &QTcpSocket::disconnected, this, &ClientHandler::sendDisable,Qt::AutoConnection);
+    }
+}
+
 void ClientHandler::sendHash()
 {
     QString path = "\\" + hashFileName;
@@ -145,6 +170,21 @@ void ClientHandler::sendDisable()
     emit sigClientDisconnected(client->getAddress(),client->getPort());
 }
 
+void ClientHandler::packetTypeInit(PacketType packet,Client *client)
+{
+    if(packet == PacketType::TYPE_QT)
+    {
+        client->setUnity(TypeClientAutorization::TYPE_QT_CLIENT);
+    }
+    else if (packet == PacketType::TYPE_UNITY)
+    {
+        client->setUnity(TypeClientAutorization::TYPE_UNITY_CLIENT);
+    }
+
+    Logger::instance().log("C: " + client->getLogin() + " send pack " + enumToString(packet));
+}
+
+
 Client *ClientHandler::getClient() const
 {
     return client;

ServerLMS/clienthandler.h

@@ -85,6 +85,9 @@ private:
 
     SendSystem *sendSystem;
     ServerLMSWidget *server;
+
+    void initClientType();
+    void packetTypeInit(PacketType packet, Client *client);
 };
 
 #endif // CLIENTHANDLER_H