refact1

LibInstructorsAndTrainees/connectorToServer/Core/FileData.h

@@ -0,0 +1,32 @@
+#include <QList>
+#include <QString>
+
+#ifndef FILEDATA_H
+#define FILEDATA_H
+
+struct FileData
+{
+    QString path;
+    QString hash;
+
+    bool operator==(const FileData& other)const{
+        if(this->path==(other.path) && this->hash == other.hash) return true;
+        return false;
+    }
+
+};   //путь
+
+struct SAttribute
+{
+    QString name;
+    QString value;
+
+};
+
+struct SXmlAnswerTag{
+    QString elementName;
+    QList<SAttribute> attr;
+};
+
+#endif // FILEDATA_H
+

LibInstructorsAndTrainees/connectorToServer/Core/dataparser.cpp

@@ -0,0 +1,582 @@
+#include "Core/dataparser.h"
+
+#include "FileData.h"
+#include "tools.h"
+
+#include "instructor.h"
+#include "trainee.h"
+#include "group.h"
+#include "tasksAmmFim.h"
+#include "streamingversiondata.h"
+
+#include <QDir>
+
+DataParser::DataParser(QObject *parent) :
+    QObject(parent)
+{
+    if(!QDir(staticDataFolderName).exists()){
+        QDir().mkdir(staticDataFolderName);
+    }
+}
+
+QByteArray DataParser::slotGetXmlAnswer(QString answerCode)
+{
+    if(answerCode == "END"){
+        return xmlAnswer_notify(answerCode);
+    }
+    return nullptr;
+}
+
+void DataParser::createFileDataList(QList<FileData> fileDataList,QString filename)
+{
+
+    QFile file(filename);
+    file.open(QIODevice::WriteOnly);
+    QXmlStreamWriter xmlWriter(&file);
+
+    xmlWriter.setAutoFormatting(true);
+    xmlWriter.writeStartDocument();
+    xmlWriter.writeStartElement("FileDataList");
+
+    foreach (FileData data,fileDataList)
+    {
+        xmlWriter.writeStartElement("FileData");
+
+        xmlWriter.writeAttribute("Path",data.path);
+        xmlWriter.writeAttribute("Hash",data.hash);
+
+        xmlWriter.writeEndElement();
+    }
+
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndDocument();
+
+    file.close();
+}
+
+QByteArray DataParser::createAuthMessage(ClientAutorization *auth)
+{
+    authPassCache = auth; //кэширование даных авторизации, для сохранения при успешном заходе
+
+    QByteArray array;
+    QXmlStreamWriter xmlWriter(&array);
+
+    xmlWriter.setAutoFormatting(true);
+    xmlWriter.writeStartDocument();
+    xmlWriter.writeStartElement("ClientAutorization");
+
+    xmlWriter.writeAttribute("Login", auth->Login);
+    xmlWriter.writeAttribute("Password", auth->Password);
+    xmlWriter.writeAttribute("TypeClient", QString::number(auth->TypeClient));
+
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndDocument();
+
+    return array;
+}
+
+QByteArray DataParser::createMessage(ClientMessage clientMessage)
+{
+    QByteArray array;
+    QXmlStreamWriter xmlWriter(&array);
+
+    xmlWriter.setAutoFormatting(true);
+    xmlWriter.writeStartDocument();
+    xmlWriter.writeStartElement("ClientMessage");
+
+    xmlWriter.writeAttribute("From",clientMessage.fromId);
+    xmlWriter.writeAttribute("To", clientMessage.toId);
+    xmlWriter.writeAttribute("Text", clientMessage.Text);
+
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndDocument();
+
+    return array;
+}
+
+
+
+QByteArray DataParser::createQueryToDBMessage(ClientQueryToDB *queryToDB, int id, void* data)
+{
+    QByteArray array;
+    QXmlStreamWriter xmlWriter(&array);
+
+    xmlWriter.setAutoFormatting(true);
+    xmlWriter.writeStartDocument();
+    xmlWriter.writeStartElement("QueryToDB");
+
+    xmlWriter.writeAttribute("TypeQuery", QString::number(queryToDB->typeQuery));
+
+    if(id)
+        xmlWriter.writeAttribute("id", QString::number(id));
+
+    if(data)
+    {
+        if(queryToDB->typeQuery == TypeQueryToDB::TYPE_QUERY_EDIT_INSTRUCTOR ||
+                queryToDB->typeQuery == TypeQueryToDB::TYPE_QUERY_NEW_INSTRUCTOR)
+        {
+            Instructor* instructor = (Instructor*)data;
+            if(instructor)
+            {
+                xmlWriter.writeAttribute("instructor_id", QString::number(instructor->getID()));
+                xmlWriter.writeAttribute("name", instructor->getName());
+                xmlWriter.writeAttribute("login", instructor->getLogin());
+                xmlWriter.writeAttribute("password", instructor->getPassword());
+                xmlWriter.writeAttribute("is_admin", QString::number(instructor->getIsAdmin()));
+                xmlWriter.writeAttribute("archived", QString::number(instructor->getArchived()));
+                xmlWriter.writeAttribute("logged_in", QString::number(instructor->getLoggedIn()));
+            }
+        }
+        else if(queryToDB->typeQuery == TypeQueryToDB::TYPE_QUERY_EDIT_TRAINEE)
+        {
+            Trainee* trainee = (Trainee*)data;
+            if(trainee)
+            {
+                xmlWriter.writeAttribute("trainee_id", QString::number(trainee->getID()));
+                xmlWriter.writeAttribute("name", trainee->getName());
+                xmlWriter.writeAttribute("login", trainee->getLogin());
+                xmlWriter.writeAttribute("password", trainee->getPassword());
+                xmlWriter.writeAttribute("archived", QString::number(trainee->getArchived()));
+                xmlWriter.writeAttribute("logged_in", QString::number(trainee->getLoggedIn()));
+                xmlWriter.writeAttribute("group_trainee", QString::number(trainee->getGroup().getID()));
+                xmlWriter.writeAttribute("computer_trainee", QString::number(trainee->getComputer().getID()));
+            }
+        }
+        else if(queryToDB->typeQuery == TypeQueryToDB::TYPE_QUERY_NEW_TRAINEE)
+        {
+            Trainee* trainee = (Trainee*)data;
+            if(trainee)
+            {
+                xmlWriter.writeAttribute("trainee_id", QString::number(trainee->getID()));
+                xmlWriter.writeAttribute("name", trainee->getName());
+                xmlWriter.writeAttribute("login", trainee->getLogin());
+                xmlWriter.writeAttribute("password", trainee->getPassword());
+                xmlWriter.writeAttribute("archived", QString::number(trainee->getArchived()));
+                xmlWriter.writeAttribute("logged_in", QString::number(trainee->getLoggedIn()));
+                xmlWriter.writeAttribute("group_trainee", QString::number(id));
+                xmlWriter.writeAttribute("computer_trainee", QString::number(trainee->getComputer().getID()));
+            }
+        }
+        else if(queryToDB->typeQuery == TypeQueryToDB::TYPE_QUERY_EDIT_GROUP ||
+                queryToDB->typeQuery == TypeQueryToDB::TYPE_QUERY_NEW_GROUP)
+        {
+            Group* group = (Group*)data;
+            if(group)
+            {
+                xmlWriter.writeAttribute("group_id", QString::number(group->getID()));
+                xmlWriter.writeAttribute("name", group->getName());
+            }
+        }
+        else if(queryToDB->typeQuery == TypeQueryToDB::TYPE_QUERY_ASSIGN_TASK_AMM_TO_TRAINEE)
+        {
+            TaskAmmFim* task = (TaskAmmFim*)data;
+            if(task)
+            {
+                xmlWriter.writeAttribute("title", task->ammProcedure.title);
+                xmlWriter.writeAttribute("dmCode", task->ammProcedure.dmCode);
+
+                for(SubProc subProc : task->listSubProc)
+                {
+                    xmlWriter.writeStartElement("SubProc");
+
+                    xmlWriter.writeAttribute("dmCode", subProc.getDmCode());
+                    xmlWriter.writeAttribute("title", subProc.getTitle());
+                    xmlWriter.writeAttribute("canplay", subProc.getModeListStr());
+
+                    xmlWriter.writeEndElement();
+                }
+            }
+        }
+        else if(queryToDB->typeQuery == TypeQueryToDB::TYPE_QUERY_ASSIGN_TASK_FIM_TO_TRAINEE)
+        {
+            TaskAmmFim* task = (TaskAmmFim*)data;
+            if(task)
+            {
+                xmlWriter.writeAttribute("title", task->title);
+
+                for(Malfunction malfunction : task->malfunctionList)
+                {
+                    xmlWriter.writeStartElement("malfunction");
+                    xmlWriter.writeAttribute("dmCode", malfunction.dmCode);
+                    xmlWriter.writeAttribute("num", malfunction.num);
+                    xmlWriter.writeAttribute("description", malfunction.description);                    
+
+                    for(MalfunctionSign sign : malfunction.malfunctionSigns)
+                    {
+                        xmlWriter.writeStartElement("malfunctionSign");
+                        xmlWriter.writeAttribute("type", QString::number(sign.type));
+                        xmlWriter.writeAttribute("description", sign.description);
+                        xmlWriter.writeEndElement();
+                    }
+
+                    xmlWriter.writeEndElement();
+                }
+            }
+        }
+        else if(queryToDB->typeQuery == TypeQueryToDB::TYPE_QUERY_CHANGE_STATUS_REPORT_TASK_AMM_TO_TRAINEE ||
+                queryToDB->typeQuery == TypeQueryToDB::TYPE_QUERY_CHANGE_STATUS_REPORT_TASK_FIM_TO_TRAINEE)
+        {
+            QString* status = (QString*)data;
+            if(status)
+            {
+                xmlWriter.writeAttribute("status", *status);
+            }
+        }
+    }
+
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndDocument();
+
+    QFile file("QueryToDB.xml");
+    file.open(QIODevice::WriteOnly);
+    file.write(array);
+    file.close();
+
+    return array;
+}
+
+QByteArray DataParser::createQueryTasksXMLMessage(QString type)
+{
+    QByteArray array;
+    QXmlStreamWriter xmlWriter(&array);
+
+    xmlWriter.setAutoFormatting(true);
+    xmlWriter.writeStartDocument();
+    xmlWriter.writeStartElement("QueryTasksXML");
+
+    xmlWriter.writeAttribute("Type", type);
+
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndDocument();
+
+    return array;
+}
+
+QByteArray DataParser::createQueryListSubProcMessage(QString dmCode)
+{
+    QByteArray array;
+    QXmlStreamWriter xmlWriter(&array);
+
+    xmlWriter.setAutoFormatting(true);
+    xmlWriter.writeStartDocument();
+    xmlWriter.writeStartElement("QueryListSubProc");
+
+    xmlWriter.writeAttribute("dmCode", dmCode);
+
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndDocument();
+
+    return array;
+}
+
+QByteArray DataParser::createDeAuthMessage(ClientDeAutorization *deAuth)
+{
+    QByteArray array;
+    QXmlStreamWriter xmlWriter(&array);
+
+    xmlWriter.setAutoFormatting(true);
+    xmlWriter.writeStartDocument();
+    xmlWriter.writeStartElement("ClientDeAutorization");
+
+    xmlWriter.writeAttribute("Login",deAuth->Login);
+
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndDocument();
+
+    return array;
+}
+
+QByteArray DataParser::createQueryBlockAuth(bool block)
+{
+    QByteArray array;
+    QXmlStreamWriter xmlWriter(&array);
+
+    xmlWriter.setAutoFormatting(true);
+    xmlWriter.writeStartDocument();
+    xmlWriter.writeStartElement("BlockAuth");
+
+    xmlWriter.writeAttribute("Block", block ? "1" : "0");
+
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndDocument();
+
+    return array;
+}
+
+
+
+void DataParser::createServerSettings(QString address, QString port)
+{
+    QFile file(settingsName);
+
+    file.open(QIODevice::WriteOnly);
+
+    QXmlStreamWriter xmlWriter(&file);
+
+    xmlWriter.setAutoFormatting(true);
+    xmlWriter.writeStartDocument();
+
+    xmlWriter.writeStartElement("ServerSettingsContainer");
+    xmlWriter.writeStartElement("ServerSettings");
+
+    xmlWriter.writeAttribute("Address",address);
+    xmlWriter.writeAttribute("Port",port);
+    xmlWriter.writeAttribute("Language","RUS");
+    xmlWriter.writeAttribute("AutoStart",QString::number(false));
+
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndElement();
+
+    xmlWriter.writeEndDocument();
+
+    file.close();
+
+}
+
+void DataParser::createAuthData(ServerAuthorization *serverAuth)
+{
+    QFile file(authTempName);
+    file.open(QIODevice::WriteOnly);
+
+    QXmlStreamWriter xmlWriter(&file);
+
+    xmlWriter.setAutoFormatting(true);
+    xmlWriter.writeStartDocument();
+    xmlWriter.writeStartElement("AuthData");
+    xmlWriter.writeAttribute("Login",authPassCache->Login);
+    xmlWriter.writeAttribute("Password",authPassCache->Password);
+    xmlWriter.writeAttribute("InstructorName",serverAuth->InstructorName);
+    xmlWriter.writeAttribute("ClientName",serverAuth->ClientName);
+    xmlWriter.writeAttribute("AccessType",serverAuth->AccessType);
+    xmlWriter.writeAttribute("id_client",serverAuth->Id);
+    xmlWriter.writeEndElement();
+    file.close();
+
+}
+
+void DataParser::createAuthDataOffline(QString username, QString pass)
+{
+    QFile file(authTempName);
+    file.open(QIODevice::WriteOnly);
+
+    QXmlStreamWriter xmlWriter(&file);
+
+    xmlWriter.setAutoFormatting(true);
+    xmlWriter.writeStartDocument();
+    xmlWriter.writeStartElement("AuthData");
+    xmlWriter.writeAttribute("Login",username);
+    xmlWriter.writeAttribute("Password",pass);
+    xmlWriter.writeAttribute("InstructorName","empty");
+    xmlWriter.writeAttribute("ClientName","Offline");
+    xmlWriter.writeAttribute("AccessType","Offline");
+
+    xmlWriter.writeEndElement();
+    file.close();
+}
+
+QByteArray DataParser::xmlAnswer_notify(QString code)
+{
+
+    QList<SXmlAnswerTag> listTag;
+
+    SAttribute attribute1 = {"Code", code};
+    QList<SAttribute> listAttr = {attribute1};
+    SXmlAnswerTag tag = {"ClientNotify", listAttr};
+
+    listTag.append(tag);
+
+    return xmlAnswer(listTag);
+}
+
+void DataParser::addRunData(QList<int> displays)
+{
+    QFile file(displayTemp);
+    file.open(QIODevice::ReadWrite);
+
+    QXmlStreamWriter xmlWriter(&file);
+    xmlWriter.setAutoFormatting(true);
+    xmlWriter.writeStartElement("DisplayInfo");
+    xmlWriter.writeAttribute("DisplayCount",QString::number(displays.length()));
+    xmlWriter.writeEndElement();
+    file.close();
+
+}
+
+ServerSettings *DataParser::getServerSettings()
+{
+    ServerSettings *settings = new ServerSettings;
+    QFile file(settingsName);
+    file.open(QIODevice::ReadOnly);
+    QXmlStreamReader xmlReader(&file);
+
+    while (!xmlReader.atEnd()){
+
+        if(xmlReader.isStartElement()){
+
+            if(xmlReader.name() == "ServerSettings")
+            {
+
+                foreach(const QXmlStreamAttribute &attr, xmlReader.attributes()){
+                    QString name = attr.name().toString();
+                    QString value = attr.value().toString();
+
+                    if(name == "Address"){
+                        settings->Address = value;
+                    }
+
+                    if(name == "Port"){
+                        settings->Port = value;
+                    }
+
+                    if(name == "Language"){
+                        settings->Language = value;
+                    }
+
+                    if(name == "AutoStart"){
+                        settings->isAutoStart = value.toInt();
+                    }
+
+                }
+            }
+        }
+
+        xmlReader.readNext();
+    }
+
+    file.close();
+    return settings;
+}
+
+void DataParser::saveClientSettrings(QString language, bool isAutoStart)
+{
+    QFile file(settingsName);
+    file.open(QIODevice::ReadOnly | QIODevice::Text);
+
+    QString settings = file.readAll();
+
+    file.close();
+    file.remove();
+
+    file.open(QIODevice::WriteOnly | QIODevice::Text);
+
+    auto languagePos = settings.indexOf(XMLLanguageProperty) + XMLLanguageProperty.length();
+    settings = settings.replace(languagePos,language.size(),language);
+
+    auto autoStartPos = settings.indexOf(XMLAutoStartProperty) + XMLAutoStartProperty.length();
+    settings = settings.replace(autoStartPos,1,QString::number(isAutoStart));
+
+    file.write(settings.toUtf8());
+    file.close();
+}
+
+QList<FileData>* DataParser::xmlFileDataParse(QByteArray array, QString filter = "")
+{
+    QXmlStreamReader xmlReader(array);
+    QList<FileData> *datas = new QList<FileData>;
+    xmlReader.readNext();   // Переходим к первому элементу в файле
+
+    //Крутимся в цикле до тех пор, пока не достигнем конца документа
+    while(!xmlReader.atEnd())
+    {
+        //Проверяем, является ли элемент началом тега
+        if(xmlReader.isStartElement())
+        {
+            if(xmlReader.name() == "FileData")
+            {
+                FileData data;
+
+                foreach(const QXmlStreamAttribute &attr,xmlReader.attributes())
+                {
+                    QString name = attr.name().toString();
+                    QString value = attr.value().toString();
+
+                    if(name == "Path")
+                        data.path = value;
+                    else if(name == "Hash")
+                        data.hash = value;
+                }
+
+                if(data.path.contains(filter))
+
+                datas->append(data);
+            }
+        }
+
+        xmlReader.readNext();
+    }
+
+    return datas;
+}
+
+QByteArray DataParser::xmlAnswer(QList<SXmlAnswerTag> listTag, QString elemUp1, QString elemUp2)
+{
+    /* Открываем файл для Записи*/
+    QFile file(tempName);
+    file.open(QIODevice::WriteOnly);
+
+    /* Создаем объект, с помощью которого осуществляется запись в файл */
+    QXmlStreamWriter xmlWriter(&file);
+
+    xmlWriter.setAutoFormatting(true);  // Устанавливаем автоформатирование текста
+
+    xmlWriter.writeStartDocument();     // Запускаем запись в документ
+
+    if(elemUp1 != "")
+        xmlWriter.writeStartElement(elemUp1);   // Записываем тег
+
+    if(elemUp2 != "")
+        xmlWriter.writeStartElement(elemUp2);   // Записываем тег
+
+    //Записываем все элементы
+    foreach(SXmlAnswerTag tag, listTag)
+    {
+        xmlWriter.writeStartElement(tag.elementName);   // Записываем тег
+
+        // Записываем атрибуты
+        foreach(SAttribute attr, tag.attr)
+            xmlWriter.writeAttribute(attr.name, attr.value);
+
+        xmlWriter.writeEndElement();        // Закрываем тег
+    }
+
+    if(elemUp1 != "")
+        xmlWriter.writeEndElement();        // Закрываем тег
+
+    if(elemUp1 != "")
+        xmlWriter.writeEndElement();        // Закрываем тег
+
+    /* Завершаем запись в документ*/
+    xmlWriter.writeEndDocument();
+
+    file.close();   // Закрываем файл
+
+    QByteArray array;
+
+    /* Открываем файл для Чтения*/
+    QFile fileR(tempName);
+    if (!fileR.open(QFile::ReadOnly | QFile::Text))
+    {
+        QString str = "Не удалось открыть файл";
+        qDebug() << "xmlAnswer: " << str;
+    }
+    else
+    {
+        array = fileR.readAll();
+        fileR.close();   // Закрываем файл
+    }
+
+    return array;
+}
+
+
+DataParser::~DataParser()
+{
+
+}

LibInstructorsAndTrainees/connectorToServer/Core/dataparser.h

@@ -0,0 +1,52 @@
+#ifndef DATAPARSER_H
+#define DATAPARSER_H
+
+#include "FileData.h"
+#include "instructor.h"
+
+#include <QObject>
+#include <Datas.h>
+#include <QFile>
+#include <QXmlStreamWriter>
+
+class DataParser : public QObject
+{
+
+    Q_OBJECT
+
+public:
+    explicit DataParser(QObject *parent = 0);
+    ~DataParser();
+    ServerSettings* getServerSettings();
+    void createServerSettings(QString server,QString port);
+    void saveClientSettrings(QString language,bool isAutoStart);
+    void createFileDataList(QList<FileData> fileDataList,QString filename);
+
+    QByteArray createAuthMessage(ClientAutorization *auth);
+    QByteArray createMessage(ClientMessage toClientMessage);
+    QByteArray createQueryToDBMessage(ClientQueryToDB *queryToDB, int id = 0, void* data = nullptr);
+    QByteArray createQueryTasksXMLMessage(QString type);
+    QByteArray createQueryListSubProcMessage(QString dmCode);
+    QByteArray createDeAuthMessage(ClientDeAutorization *deAuth);
+
+    QByteArray createQueryBlockAuth(bool block);
+
+    void createAuthData(ServerAuthorization *serverAuth);
+    void createAuthDataOffline(QString username,QString pass);
+    void addRunData(QList<int> displays);
+    QByteArray xmlAnswer_notify(QString code);
+    QByteArray xmlAnswer(QList<SXmlAnswerTag> listTag, QString elemUp1 = "", QString elemUp2 = "");
+
+    QList<FileData>* xmlFileDataParse(QByteArray array,QString filter);
+public slots:
+    QByteArray slotGetXmlAnswer(QString);
+
+
+private:
+    const QString XMLLanguageProperty = "Language=\"";
+    const QString XMLAutoStartProperty = "AutoStart=\"";
+    ClientAutorization *authPassCache;
+
+};
+
+#endif // DATAPARSER_H

LibInstructorsAndTrainees/connectorToServer/Core/recognizesystem.cpp

@@ -0,0 +1,974 @@
+#include "Core/recognizesystem.h"
+#include <QThread>
+#include <QDir>
+#include <QDomDocument>
+#include <QMessageBox>
+#include "instructor.h"
+#include "tasksAmmFim.h"
+#include "module.h"
+#include "timingoftrainee.h"
+#include "specialmessagebox.h"
+
+
+RecognizeSystem::RecognizeSystem(QObject *parent):
+    QObject(parent)
+{
+    packetType = PacketType::TYPE_NONE;
+    filePath.clear();
+    fileSize = 0;
+    message.clear();
+    sizeReceiveData = 0;
+    tmpBlock.clear();
+    countSend = 0;
+    folderList = new QList<QString>;
+}
+
+RecognizeSystem::~RecognizeSystem()
+{
+
+}
+
+void RecognizeSystem::initialize(DataParser *dataParser/*,MainWindow *mainWindow*/)
+{
+    this->dataParser = dataParser;
+    //this->mainWindow = mainWindow;
+    connect(this,&RecognizeSystem::sigAuth,dataParser,&DataParser::createAuthData);
+}
+
+void RecognizeSystem::recognize(QTcpSocket *socket)
+{
+    qDebug() << "RecognizeThreadId " << QThread::currentThreadId();
+
+    QDataStream stream(socket);
+    stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);
+
+    while(socket->bytesAvailable())
+    {
+
+      if (socket->state() != QTcpSocket::ConnectedState) return;
+
+        if(packetType == PacketType::TYPE_NONE){    //определение первичного пакета
+
+            stream.startTransaction();
+            stream >> packetType;
+
+            if(!stream.commitTransaction()){
+                emit sigSendDebugLog(Tools::getTime() + " CLIENT: packetType - FAIL commitTransaction");
+
+                if(socket->waitForReadyRead(TCP_READ_TIMEOUT)){
+                    emit sigSendDebugLog("ERROR: PACKET TYPE READ TIMEOUT");
+                    return;
+                }
+                continue;
+
+            }
+
+            //qDebug() << Tools::GetTime() << "CLIENT: type: " << packetType;
+        }
+
+        if(packetType == PacketType::TYPE_FOLDER){  //создание папок
+            stream.startTransaction();
+            stream >> filePath;
+
+            if(!stream.commitTransaction()){
+                continue;
+            }
+
+            filePath = Tools::createFullPath(filePath);
+
+            QDir dir(filePath);
+            if(!dir.exists()){
+                if(dir.mkpath(filePath)){
+                    qDebug() << "Dir Created";
+                }
+            }
+
+            packetType = PacketType::TYPE_NONE;
+            emit sigUpdateBytesAvailable();
+            continue;
+        }
+
+        if(packetType == PacketType::TYPE_FILE)     //загрузка файлов
+        {
+            //ПОЛУЧЕНИЕ ПУТИ
+            //ПОЛУЧЕНИЕ РАЗМЕРА ФАЙЛА
+            forever
+            {
+                stream.startTransaction();
+                stream >> filePath;
+                stream >> fileSize;
+
+                if(!stream.commitTransaction()){
+                    emit sigSendDebugLog(Tools::getTime() + "CLIENT: filePath, fileSize - FAIL commitTransaction");
+
+                    if (!socket->waitForReadyRead(TCP_READ_TIMEOUT)) {
+                        emit sigSendDebugLog(Tools::getTime() + "CLIENT: ERROR! readyRead timeout - filePath, fileSize!!!");
+                        return;
+                    }
+                    continue;
+
+                }
+
+                filePath = Tools::createFullPath(filePath);
+
+                emit sigSendDebugLog("CLIENT: filesize: " + QString::number(fileSize));
+                emit sigSendDebugLog("CLIENT: filePath: " + filePath);
+
+                socket->waitForReadyRead(100);
+                break;
+            }
+
+
+            //ПОЛУЧЕНИЕ САМОГО ФАЙЛА
+            emit sigSendDebugLog(Tools::getTime() + "AfterRead size and path BytesAvailable: " + socket->bytesAvailable());
+
+            //УКАЗАНИЕ ПУТИ ФАЙЛА
+            QFile file(filePath);
+
+            if (file.exists())
+            {
+                file.remove();  //удаление файла, если он уже есть, но необходимо обновить
+                emit sigSendDebugLog(Tools::getTime() + "Delete exist file: " + filePath);
+                socket->waitForReadyRead(100);
+            }
+
+
+
+            file.open(QFile::Append);
+
+            forever
+            {
+                stream.startTransaction();
+                stream >> tmpBlock;
+
+                if(!stream.commitTransaction()){
+
+                    if(socket->state() == QAbstractSocket::UnconnectedState){
+                        emit sigSocketDisabled();
+                        return;
+                    }
+                    if(socket->waitForReadyRead(TCP_READ_TIMEOUT)){
+                        continue;
+                    }
+
+                    continue;
+                }
+
+                quint64 toFile = file.write(tmpBlock);
+                emit sigSendDebugLog(Tools::getTime() + "CLIENT: toFile :" + toFile);
+
+                sizeReceiveData += toFile;
+                countSend++;
+
+                tmpBlock.clear();
+
+                if(sizeReceiveData == fileSize){
+                    emit sigSendDebugLog(Tools::getTime() + "FINAL Count send: " + QString::number(countSend));
+                    emit sigSendDebugLog(Tools::getTime() + "FINAL Size received: " + QString::number(sizeReceiveData));
+                    emit sigSendDebugLog(Tools::getTime() + "FINAL File size" + QString::number(fileSize));
+                    emit sigUpdateBytesAvailable();
+                    break;
+                }
+            }
+
+            file.close();
+            emit sigSendDebugLog(Tools::getTime() + "File loaded");
+
+            //ОЧИСТКА ПОСЛЕ ПЕРЕДАЧИ
+
+            filePath.clear();
+            fileSize = 0;
+            tmpBlock.clear();
+            sizeReceiveData = 0;
+            countSend = 0;
+        }
+
+        if(packetType == PacketType::TYPE_DELETE)   //удаление лишних файлов (рекурсивно удаляет все содежимое)
+        {
+            stream.startTransaction();
+            stream >> filePath;
+
+            if(!stream.commitTransaction()){
+                continue;
+            }
+
+            filePath = Tools::createFullPath(filePath);
+
+            QFileInfo fileInfo(filePath);
+
+
+            if(fileInfo.exists())
+            {
+                if(fileInfo.isFile())
+                {
+                    QFile file(filePath);
+                    file.remove();
+                }
+
+                if(fileInfo.isDir()){
+                    QDir dir(filePath);
+                    dir.removeRecursively();
+                }
+
+                qDebug() << Tools::getTime() << "Deleted: " << filePath;
+            }
+
+            packetType = PacketType::TYPE_NONE;
+            continue;
+
+        }
+
+        if(packetType ==PacketType::TYPE_FINISH){   //для повторного создания хэша после загрузки
+            //updateController->calculateCommonHash();
+            emit sigLoadComplete();
+            packetType = PacketType::TYPE_NONE;
+        }
+
+        if(packetType == PacketType::TYPE_NEEDUPDATE){  //нужно обновление
+
+            bool flag = false;
+            quint64 size = 0;
+            quint64 fileCount = 0;
+
+            stream.startTransaction();
+            stream >> flag;
+            stream >> size;
+            stream >> fileCount;
+
+            if(!stream.commitTransaction()){
+                continue;
+            }
+
+            emit sigNeedUpdate(flag,size,fileCount);
+            packetType = PacketType::TYPE_NONE;
+        }
+
+        if(packetType == PacketType::TYPE_XMLANSWER){   //ответы формата XML
+            QByteArray array;
+            stream.startTransaction();
+            stream >> array;
+
+            if(!stream.commitTransaction()){
+                continue;
+            }
+
+            xmlParser(array);
+
+            packetType = PacketType::TYPE_NONE;
+        }
+
+
+        if(packetType == PacketType::BUSY)
+        {
+            emit sigAnimationActivated(true);
+        }
+
+        if(packetType == PacketType::FREE)
+        {
+            emit sigAnimationActivated(false);
+        }
+
+        if(packetType == PacketType::HASH_READY)
+        {
+            emit sigHashReady();
+        }
+
+        if(packetType == PacketType::TYPE_XMLANSWER_DOCS_CHANGED)
+        {
+            emit signal_AnswerDocsChanged();
+        }
+
+        //if(packetType == PacketType::TYPE_XMLANSWER_QUERY_LIST_SUB_PROC_AMM)
+        //{
+
+        //}
+
+        //А)xml-ответы на запросы к БД
+        //B)перечни Подпроцедур
+        switch(packetType)
+        {
+        case TYPE_XMLANSWER_QUERY_DB__LIST_INSTRUCTORS:
+        case TYPE_XMLANSWER_QUERY_DB__LIST_GROUPS:
+        case TYPE_XMLANSWER_QUERY_DB__LIST_TRAINEES:
+        case TYPE_XMLANSWER_QUERY_DB__LIST_COMPUTERS:
+        case TYPE_XMLANSWER_QUERY_DB__LIST_CLASSROOMS:
+        case TYPE_XMLANSWER_QUERY_TASKS_AMM_FOR_TRAINEE:
+        case TYPE_XMLANSWER_QUERY_TASKS_FIM_FOR_TRAINEE:
+        case TYPE_XMLANSWER_QUERY_LIST_SUB_PROC_AMM:
+            {
+                //ПОЛУЧЕНИЕ РАЗМЕРА ФАЙЛА
+                forever
+                {
+                    stream.startTransaction();
+                    stream >> fileSize;
+
+                    if(!stream.commitTransaction()){
+                        emit sigSendDebugLog(Tools::getTime() + "CLIENT: fileSize - FAIL commitTransaction");
+
+                        if (!socket->waitForReadyRead(TCP_READ_TIMEOUT)) {
+                            emit sigSendDebugLog(Tools::getTime() + "CLIENT: ERROR! readyRead timeout - fileSize!!!");
+                            return;
+                        }
+                        continue;
+
+                    }
+
+                    emit sigSendDebugLog("CLIENT: filesize: " + QString::number(fileSize));
+
+                    socket->waitForReadyRead(100);
+                    break;
+                }
+
+
+                //ПОЛУЧЕНИЕ САМОГО ФАЙЛА
+                emit sigSendDebugLog(Tools::getTime() + "AfterRead size and path BytesAvailable: " + socket->bytesAvailable());
+
+                QByteArray array;
+
+                forever
+                {
+                    stream.startTransaction();
+                    stream >> tmpBlock;
+
+                    if(!stream.commitTransaction()){
+
+                        if(socket->state() == QAbstractSocket::UnconnectedState){
+                            emit sigSocketDisabled();
+                            return;
+                        }
+                        if(socket->waitForReadyRead(TCP_READ_TIMEOUT)){
+                            continue;
+                        }
+
+                        continue;
+                    }
+
+                    array.append(tmpBlock);
+
+                    emit sigSendDebugLog(Tools::getTime() + "CLIENT: toFile :" + array.size());
+
+                    sizeReceiveData += array.size();
+                    countSend++;
+
+                    tmpBlock.clear();
+
+                    if(sizeReceiveData == fileSize){
+                        emit sigSendDebugLog(Tools::getTime() + "FINAL Count send: " + QString::number(countSend));
+                        emit sigSendDebugLog(Tools::getTime() + "FINAL Size received: " + QString::number(sizeReceiveData));
+                        emit sigSendDebugLog(Tools::getTime() + "FINAL File size" + QString::number(fileSize));
+                        emit sigUpdateBytesAvailable();
+                        break;
+                    }
+                }
+
+                emit sigSendDebugLog(Tools::getTime() + "File loaded");
+
+                //ОЧИСТКА ПОСЛЕ ПЕРЕДАЧИ
+                fileSize = 0;
+                tmpBlock.clear();
+                sizeReceiveData = 0;
+                countSend = 0;
+
+                if(packetType != TYPE_XMLANSWER_QUERY_LIST_SUB_PROC_AMM)
+                {//xml-ответы на запросы к БД
+                    xmlParserQueryToDB(packetType, array);
+                }
+                else
+                {//перечни Подпроцедур
+                    xmlParserQuerySubProc(packetType, array);
+                }
+
+                packetType = PacketType::TYPE_NONE;
+
+
+
+                /*
+                QByteArray array;
+                stream.startTransaction();
+                stream >> array;
+
+                if(!stream.commitTransaction())
+                    continue;
+
+                xmlParserQueryToDB(packetType, array);
+
+                packetType = PacketType::TYPE_NONE;
+                */
+            }
+            break;
+        };
+
+        //xml-ответы на запросы AdditionalFiles (сигнал о чтении ранее принятого)
+        if(packetType == PacketType::TYPE_XMLANSWER_QUERY_TASKS_XML_FIM ||
+                packetType == PacketType::TYPE_XMLANSWER_QUERY_TASKS_XML_AMM)
+        {
+            QByteArray array;            
+            QString xmlFileName = "";
+
+            if(packetType == PacketType::TYPE_XMLANSWER_QUERY_TASKS_XML_FIM)
+                xmlFileName = "./" + additionalFilesFolderName + "/tasksFIM.xml";
+            else
+                xmlFileName = "./" + additionalFilesFolderName + "/docs.xml"; //"/tasksAMM.xml";
+
+            QFile xmlInFile(xmlFileName);
+            if (!xmlInFile.open(QFile::ReadOnly | QFile::Text))
+            {
+                SpecMsgBox::CriticalClose(nullptr, tr("The file could not be opened ") + xmlFileName);
+                return;
+            }
+            else
+            {
+                array = xmlInFile.readAll();
+                xmlInFile.close();
+            }
+
+            xmlParserQueryTasksXML(packetType, array);
+
+            packetType = PacketType::TYPE_NONE;
+        }
+
+        packetType = PacketType::TYPE_NONE;
+    }
+}
+
+void RecognizeSystem::xmlParser(QByteArray array)
+{
+    QXmlStreamReader xmlReader(array);
+
+    xmlReader.readNext();
+    QString name = xmlReader.name().toString();
+
+    while(!xmlReader.atEnd())
+    {
+        name = xmlReader.name().toString();
+
+        if(!xmlReader.isStartElement()) {
+            xmlReader.readNext();
+            continue;
+        }
+
+        if(xmlReader.name() == "ServerNotify")
+        {
+            foreach(const QXmlStreamAttribute &attr, xmlReader.attributes())
+            {
+                QString name = attr.name().toString();
+                QString value = attr.value().toString();
+
+                if(name == "Code")
+                {
+                    if (value == NOTIFY_SERVER_END)
+                    {
+                        emit sigSocketDisabled();
+                    }
+
+                    if(value == NOTIFY_SERVER_BLOCKED)
+                    {
+                        emit sigServerBlocked();
+                    }
+
+                    if(value == NOTIFY_ERROR_AUTH_DB)
+                    {
+                        emit sigErrorAuth(value);
+                    }
+                    if(value == NOTIFY_ERROR_AUTH_LOGINORPASSWORD)
+                    {
+                        emit sigErrorAuth(value);
+                    }
+                    if(value == NOTIFY_ERROR_AUTH_ARCHIVED)
+                    {
+                        emit sigErrorAuth(value);
+                    }
+                    if(value == NOTIFY_ERROR_AUTH_ALREADYLOGIN)
+                    {
+                        emit sigErrorAuth(value);
+                    }
+
+                    if(value == "HASHSENDCOMPLETE")
+                    {
+                        emit sigStartCompare();
+                    }
+
+                    if (value == "BASEDELETETRY")
+                    {
+                        emit sigNotifyVersionControl(tr("You cannot delete the basic version!"));
+                    }
+
+                    if (value == "TRYACTIVEDELETE")
+                    {
+                        emit sigNotifyVersionControl(tr("You cannot delete the active version"));
+                    }
+
+                    if (value == "DUPLICATEVERNAME")
+                    {
+                        emit sigNotifyVersionControl(tr("This name already exists"));
+                    }
+                }
+            }
+        }
+
+        if(xmlReader.name() == "ServerAuthorization"){
+
+            ServerAuthorization *serverAuth = new ServerAuthorization;
+
+            foreach(const QXmlStreamAttribute &attr, xmlReader.attributes())
+            {
+                QString name = attr.name().toString();
+                QString value = attr.value().toString();
+
+                if (name == "Result"){
+                    serverAuth->Result = value == "true" ? true : false;
+                }
+
+                if (name == "InstructorName"){
+                    serverAuth->InstructorName = value;
+                }
+
+                if (name == "ClientName"){
+                    serverAuth->ClientName = value;
+                }
+
+                if (name == "AccessType"){
+                    serverAuth->AccessType = value;
+                    checkAccessType(value);
+                }
+
+                if (name == "Login"){
+                    serverAuth->Login = value;
+                }
+
+                if (name == "id_client")
+                {
+                    serverAuth->Id = value;
+                }
+            }
+
+            emit sigAuth(serverAuth);
+        }
+
+        if(xmlReader.name() == "ClientMessage"){
+
+            ClientMessage *clientMessage = new ClientMessage;
+
+            foreach(const QXmlStreamAttribute &attr, xmlReader.attributes())
+            {
+                QString name = attr.name().toString();
+                QString value = attr.value().toString();
+
+                if (name == "From"){
+                    clientMessage->fromId = value;
+                }
+
+                if (name == "To"){
+                    clientMessage->toId = value;
+                }
+
+                if (name == "Text"){
+                    clientMessage->Text = value;
+                }
+            }
+
+            emit signal_ReceiveMessage(*clientMessage);
+        }
+
+        if(xmlReader.name() == "ServerDeAuthorization"){
+
+            ServerDeAuthorization *serverDeAuth = new ServerDeAuthorization;
+
+            foreach(const QXmlStreamAttribute &attr, xmlReader.attributes())
+            {
+                QString name = attr.name().toString();
+                QString value = attr.value().toString();
+
+                if (name == "Result"){
+                    serverDeAuth->Result = value == "true" ? true : false;
+                }
+
+                if (name == "Login"){
+                    serverDeAuth->Login = value;
+                }
+            }
+
+            emit sigDeAuth(serverDeAuth);
+
+        }
+
+
+        if(xmlReader.name() == "VersionList")
+        {
+            QList<StreamingVersionData*> *serverStreamingVersionDataList = new QList<StreamingVersionData*>;
+            xmlReader.readNext();
+
+            while (!xmlReader.atEnd())
+            {
+                if(xmlReader.isStartElement())
+                {
+                    if(xmlReader.name() == "VersionData")
+                    {
+                        StreamingVersionData *data = new StreamingVersionData;
+
+                        foreach(const QXmlStreamAttribute &attr,xmlReader.attributes())
+                        {
+                            QString name = attr.name().toString();
+                            QString value = attr.value().toString();
+
+                            if(name == "Version")
+                                data->setName(value);
+                            else if(name == "Created")
+                                data->setCreateData(QDateTime::fromString(value));
+                            else if(name == "isChangeable")
+                                data->setIsChangeable(value.toInt());
+                            else if(name == "author")
+                                data->setAuthor(value);
+
+                        }
+
+                        serverStreamingVersionDataList->append(data);
+                    }
+                }
+
+                xmlReader.readNext();
+            }
+
+            emit sigShowServerDataList(serverStreamingVersionDataList);
+        }
+
+        if(xmlReader.name() == "VersionData")
+        {
+            StreamingVersionData *serverVersion = new StreamingVersionData;
+            foreach(const QXmlStreamAttribute &attr,xmlReader.attributes())
+            {
+                QString name = attr.name().toString();
+                QString value = attr.value().toString();
+
+                if (name == "Version")
+                {
+                    serverVersion->setName(value);
+                }
+
+                if (name == "Created")
+                {
+                    serverVersion->setCreateData(QDateTime::fromString(value));
+                }
+
+                if (name == "isChangeable")
+                {
+                    serverVersion->setIsChangeable(value.toInt());
+                }
+
+            }
+
+            emit sigSetVersion(serverVersion);
+        }
+
+        xmlReader.readNext();
+    }
+}
+
+void RecognizeSystem::xmlParserQueryToDB(PacketType packetType, QByteArray array)
+{
+    QDomDocument commonDOM;
+    commonDOM.setContent(array);
+
+    switch(packetType)
+    {
+        case TYPE_XMLANSWER_QUERY_DB__LIST_INSTRUCTORS:
+        {
+            QList<Instructor> listInstructors;
+            QDomNode listNode = commonDOM.namedItem("ListInstructors");
+
+            for(int i = 0; i < listNode.childNodes().count(); i++)
+            {
+                QDomNode instructorNode = listNode.childNodes().at(i);
+                if(instructorNode.nodeName() == "Instructor")
+                {//Инструктор
+                    Instructor instructor;
+                    instructor.setID(instructorNode.toElement().attribute("instructor_id").toInt());
+                    instructor.setName(instructorNode.toElement().attribute("name"));
+                    instructor.setLogin(instructorNode.toElement().attribute("login"));
+                    instructor.setPassword(instructorNode.toElement().attribute("password"));
+                    instructor.setIsAdmin(instructorNode.toElement().attribute("is_admin").toInt());
+                    instructor.setArchived(instructorNode.toElement().attribute("archived").toInt());
+                    instructor.setLoggedIn(instructorNode.toElement().attribute("logged_in").toInt());
+
+                    listInstructors.append(instructor);
+                }
+            }
+            emit sigAnswerQueryToDB_ListInstructors(listInstructors);
+        }
+        break;
+        case TYPE_XMLANSWER_QUERY_DB__LIST_GROUPS:
+        {
+            QList<Group> listGroups;
+            QDomNode listNode = commonDOM.namedItem("ListGroups");
+
+            for(int i = 0; i < listNode.childNodes().count(); i++)
+            {
+                QDomNode groupNode = listNode.childNodes().at(i);
+                if(groupNode.nodeName() == "Group")
+                {//Группа
+                    Group group;
+                    group.setID(groupNode.toElement().attribute("group_id").toInt());
+                    group.setName(groupNode.toElement().attribute("name"));
+
+                    listGroups.append(group);
+                }
+            }
+            emit sigAnswerQueryToDB_ListGroups(listGroups);
+        }
+        break;
+        case TYPE_XMLANSWER_QUERY_DB__LIST_TRAINEES:
+        {
+            QList<Trainee> listTrainees;
+            QDomNode listNode = commonDOM.namedItem("ListTrainees");
+
+            for(int i = 0; i < listNode.childNodes().count(); i++)
+            {
+                QDomNode traineeNode = listNode.childNodes().at(i);
+                if(traineeNode.nodeName() == "Trainee")
+                {//Обучаемый
+                    Trainee trainee;
+                    trainee.setID(traineeNode.toElement().attribute("trainee_id").toInt());
+                    trainee.setName(traineeNode.toElement().attribute("name"));
+                    trainee.setLogin(traineeNode.toElement().attribute("login"));
+                    trainee.setPassword(traineeNode.toElement().attribute("password"));
+                    trainee.setArchived(traineeNode.toElement().attribute("archived").toInt());
+                    trainee.setLoggedIn(traineeNode.toElement().attribute("logged_in").toInt());
+                    Group group(traineeNode.toElement().attribute("group_trainee").toInt(), "");
+                    trainee.setGroup(group);
+                    //trainee.setComputer()
+                    //trainee.setTasks()
+
+
+                    //Тайминг
+                    QDomNode timingNode = traineeNode.firstChildElement("timing");
+
+                    TimingOfTrainee timing(trainee.getID());
+                    timing.setEntryTimeS(timingNode.toElement().attribute("entryTime"));
+                    timing.setExitTimeS(timingNode.toElement().attribute("exitTime"));
+                    timing.setOperatingTimeS(timingNode.toElement().attribute("operatingTime"));
+
+                    trainee.setTiming(timing);
+
+
+                    listTrainees.append(trainee);
+                }
+            }
+            emit sigAnswerQueryToDB_ListTrainees(listTrainees);
+        }
+        break;
+        case TYPE_XMLANSWER_QUERY_DB__LIST_COMPUTERS:
+        {
+            QList<Computer> listComputers;
+            QDomNode listNode = commonDOM.namedItem("ListComputers");
+
+            for(int i = 0; i < listNode.childNodes().count(); i++)
+            {
+                QDomNode computerNode = listNode.childNodes().at(i);
+                if(computerNode.nodeName() == "Computer")
+                {//Компьютер
+                    Computer computer;
+                    computer.setID(computerNode.toElement().attribute("computer_id").toInt());
+                    computer.setName(computerNode.toElement().attribute("name"));
+                    computer.setIpAddress(computerNode.toElement().attribute("ip_address"));
+                    //computer.setClassroom
+
+                    listComputers.append(computer);
+                }
+            }
+            emit sigAnswerQueryToDB_ListComputers(listComputers);
+        }
+        break;
+        case TYPE_XMLANSWER_QUERY_DB__LIST_CLASSROOMS:
+        {
+            QList<Classroom> listClassrooms;
+            QDomNode listNode = commonDOM.namedItem("ListClassrooms");
+
+            for(int i = 0; i < listNode.childNodes().count(); i++)
+            {
+                QDomNode classroomNode = listNode.childNodes().at(i);
+                if(classroomNode.nodeName() == "Classroom")
+                {//Класс
+                    Classroom classroom;
+                    classroom.setID(classroomNode.toElement().attribute("classroom_id").toInt());
+                    classroom.setName(classroomNode.toElement().attribute("name"));
+
+                    listClassrooms.append(classroom);
+                }
+            }
+            emit sigAnswerQueryToDB_ListClassrooms(listClassrooms);
+        }
+        break;
+        case TYPE_XMLANSWER_QUERY_TASKS_AMM_FOR_TRAINEE:
+        {
+            QList<TaskAmmFim> listTasks;
+            int trainee_id = 0;
+            QDomNode listNode = commonDOM.namedItem("ListTasksAMM");
+            trainee_id = listNode.toElement().attribute("trainee_id").toInt();
+
+            for(int i = 0; i < listNode.childNodes().count(); i++)
+            {
+                QDomNode taskNode = listNode.childNodes().at(i);
+                if(taskNode.nodeName() == "taskAMM")
+                {//Задача
+                    TaskAmmFim task;
+                    task.setID(taskNode.toElement().attribute("task_id").toInt());
+                    task.ammProcedure.title = taskNode.toElement().attribute("title");
+                    task.ammProcedure.dmCode = taskNode.toElement().attribute("dmCode");
+                    task.status = taskNode.toElement().attribute("status");
+
+                    for(int j = 0; j < taskNode.childNodes().count(); j++)
+                    {
+                        QDomNode subProcNode = taskNode.childNodes().at(j);
+                        if(subProcNode.nodeName() == "SubProc")
+                        {//Подпроцедура
+                            SubProc subProc;
+                            subProc.setDmCode(subProcNode.toElement().attribute("dmCode"));
+                            subProc.setTitle(subProcNode.toElement().attribute("title"));
+                            subProc.setModeListStr(subProcNode.toElement().attribute("canplay"));
+
+                            task.listSubProc.append(subProc);
+                        }
+                    }
+
+                    listTasks.append(task);
+                }
+            }
+            emit sigAnswerQueryToDB_ListTasksAMMforTrainee(listTasks, trainee_id);
+        }
+        break;
+        case TYPE_XMLANSWER_QUERY_TASKS_FIM_FOR_TRAINEE:
+        {
+            QList<TaskAmmFim> listTasks;
+            int trainee_id = 0;
+            QDomNode listNode = commonDOM.namedItem("ListTasksFIM");
+            trainee_id = listNode.toElement().attribute("trainee_id").toInt();
+
+            for(int i = 0; i < listNode.childNodes().count(); i++)
+            {//Задачи
+                QDomNode taskNode = listNode.childNodes().at(i);
+                if(taskNode.nodeName() == "taskFIM")
+                {
+                    TaskAmmFim task;
+                    task.setID(taskNode.toElement().attribute("task_id").toInt());
+                    task.title = taskNode.toElement().attribute("title");
+                    task.status = taskNode.toElement().attribute("status");
+
+                    for(int j = 0; j < taskNode.childNodes().count(); j++)
+                    {
+                        QDomNode malfOrReportNode = taskNode.childNodes().at(j);
+                        if(malfOrReportNode.nodeName() == "malfunction")
+                        {//Неисправность
+                            Malfunction malfunction;
+                            malfunction.num = malfOrReportNode.toElement().attribute("num");
+                            malfunction.dmCode = malfOrReportNode.toElement().attribute("dmCode");
+                            malfunction.description = malfOrReportNode.toElement().attribute("description");
+
+                            for(int s = 0; s < malfOrReportNode.childNodes().count(); s++)
+                            {
+                                QDomNode signNode = malfOrReportNode.childNodes().at(s);
+                                if(signNode.nodeName() == "malfunctionSign")
+                                {
+                                    MalfunctionSign sign;
+                                    sign.type = signNode.toElement().attribute("type").toInt();
+                                    sign.description = signNode.toElement().attribute("description");
+
+                                    malfunction.malfunctionSigns.append(sign);
+                                }
+                            }
+
+                            task.malfunctionList.append(malfunction);
+                        }
+                        else
+                            if(malfOrReportNode.nodeName() == "report")
+                            {//Отчет
+                                FIMReport report;
+                                report.id = malfOrReportNode.toElement().attribute("report_id").toInt();
+
+                                for(int k = 0; k < malfOrReportNode.childNodes().count(); k++)
+                                {
+                                    QDomNode reportItemNode = malfOrReportNode.childNodes().at(k);
+                                    if(reportItemNode.nodeName() == "reportItem")
+                                    {
+                                        FIMReportItem reportItem;
+                                        reportItem.id = reportItemNode.toElement().attribute("item_id").toInt();
+                                        reportItem.text = reportItemNode.toElement().attribute("text");
+
+                                        if(reportItemNode.childNodes().count())
+                                        {
+                                            QDomNode procedureIDNode = reportItemNode.childNodes().at(0);
+                                            reportItem.procedure.doc = procedureIDNode.toElement().attribute("doc");
+                                            reportItem.procedure.title = procedureIDNode.toElement().attribute("title");
+                                            reportItem.procedure.dmCode = procedureIDNode.toElement().attribute("dmCode");
+                                            reportItem.procedure.result = procedureIDNode.toElement().attribute("result");
+                                        }
+
+                                        report.itemList.append(reportItem);
+                                    }
+                                }
+
+                                task.report = report;
+                            }
+                    }
+
+                    listTasks.append(task);
+                }
+            }
+            emit sigAnswerQueryToDB_ListTasksFIMforTrainee(listTasks, trainee_id);
+        }
+        break;
+    };
+}
+
+void RecognizeSystem::xmlParserQuerySubProc(PacketType packetType, QByteArray array)
+{
+    QDomDocument commonDOM;
+    commonDOM.setContent(array);
+
+    switch(packetType)
+    {
+        case TYPE_XMLANSWER_QUERY_LIST_SUB_PROC_AMM:
+        {
+            QList<SubProc> listSubProc;
+            QString parentTask_dmCode = "";
+            QDomNode listNode = commonDOM.namedItem("ListSubProc");
+            parentTask_dmCode = listNode.toElement().attribute("dmCode");
+
+            for(int i = 0; i < listNode.childNodes().count(); i++)
+            {
+                QDomNode taskNode = listNode.childNodes().at(i);
+                if(taskNode.nodeName() == "SubProc")
+                {//Подпроцедура
+                    SubProc subProc;
+                    subProc.setTitle(taskNode.toElement().attribute("title"));
+                    subProc.setDmCode(taskNode.toElement().attribute("dmCode"));
+                    subProc.setModeListStr(taskNode.toElement().attribute("canplay"));
+
+                    listSubProc.append(subProc);
+                }
+            }
+            emit sigAnswerQuerySubProc(listSubProc, parentTask_dmCode);
+        }
+        break;
+    };
+
+}
+
+void RecognizeSystem::xmlParserQueryTasksXML(PacketType packetType, QByteArray array)
+{
+    if(packetType == TYPE_XMLANSWER_QUERY_TASKS_XML_FIM)
+    {
+        emit sigAnswerQueryTasksXML_FIM(array);
+    }
+    else if(packetType == TYPE_XMLANSWER_QUERY_TASKS_XML_AMM)
+    {
+        emit sigAnswerQueryTasksXML_AMM(array);
+    }
+}
+
+void RecognizeSystem::checkAccessType(QString type)
+{
+    if(type == "instructor")
+    {
+        //mainWindow->callUpdateList();
+    }
+}

LibInstructorsAndTrainees/connectorToServer/Core/recognizesystem.h

@@ -0,0 +1,87 @@
+#ifndef RECOGNIZESYSTEM_H
+#define RECOGNIZESYSTEM_H
+
+#include <QObject>
+#include <QDataStream>
+#include <QTcpSocket>
+#include <streamingVersionData.h>
+//#include <mainwindow.h>
+#include <Core\tools.h>
+#include "dataparser.h"
+#include "instructor.h"
+#include "trainee.h"
+#include "group.h"
+#include "Datas.h"
+#include "tasksAmmFim.h"
+#include "module.h"
+
+
+class RecognizeSystem : public QObject
+{
+
+    Q_OBJECT
+
+public:
+    explicit RecognizeSystem(QObject *parent = 0);
+    ~RecognizeSystem();
+    void initialize(DataParser *dataParser/*,MainWindow *mainWindow*/);
+    void recognize(QTcpSocket *socket);
+
+signals:
+    void sigUpdateBytesAvailable();
+    void sigLoadComplete();
+    void sigNeedUpdate(bool flag,qint64 size,quint64 fileCount);
+    void sigSendDebugLog(QString message);
+    void sigSocketDisabled();
+    void sigServerBlocked();
+    void sigErrorAuth(QString error);
+    void sigAuth(ServerAuthorization *serverAuth);
+    void sigDeAuth(ServerDeAuthorization *serverDeAuth);
+    void sigAnswerQueryToDB(QList<Instructor>* listInstructors,
+                            QList<Trainee>* listTrainees,
+                            QList<Group>* listGroups);
+    void sigSocketWaitForReadyRead(int waitTime);
+    void sigStartCompare();
+
+    void signal_ReceiveMessage(ClientMessage clientMessage);
+
+    void sigAnswerQueryToDB_ListInstructors(QList<Instructor> listInstructors);
+    void sigAnswerQueryToDB_ListGroups(QList<Group> listGroups);
+    void sigAnswerQueryToDB_ListTrainees(QList<Trainee> listTrainees);
+    void sigAnswerQueryToDB_ListComputers(QList<Computer> listComputers);
+    void sigAnswerQueryToDB_ListClassrooms(QList<Classroom> listClassrooms);
+    void sigAnswerQueryToDB_ListTasksAMMforTrainee(QList<TaskAmmFim>listTasks, int trainee_id);
+    void sigAnswerQueryToDB_ListTasksFIMforTrainee(QList<TaskAmmFim>listTasks, int trainee_id);
+    void sigAnswerQueryTasksXML_FIM(QByteArray array);
+    void sigAnswerQueryTasksXML_AMM(QByteArray array);
+    void sigShowServerDataList(QList<StreamingVersionData*> *versions);
+    void sigSetVersion(StreamingVersionData* serverVersion);
+    void sigNotifyVersionControl(QString text);
+    void sigAnimationActivated(bool flag);
+    void sigHashReady();
+    void sigAnswerQuerySubProc(QList<SubProc> listSubProc, QString parentTask_dmCode);
+
+    void signal_AnswerDocsChanged();
+
+private:
+    QList<QString> *folderList;
+    //MainWindow *mainWindow;
+    DataParser *dataParser;
+    PacketType packetType;
+    QString message;
+    QString filePath;
+    QByteArray tmpBlock;
+
+    qint64 sizeReceiveData;
+    qint64 fileSize;
+    int countSend;
+
+    void xmlParser(QByteArray array);
+    void xmlParserQueryToDB(PacketType packetType, QByteArray array);
+    void xmlParserQuerySubProc(PacketType packetType, QByteArray array);
+    void xmlParserQueryTasksXML(PacketType packetType, QByteArray array);
+
+    void checkAccessType(QString type);
+};
+
+#endif // RECOGNIZESYSTEM_H

LibInstructorsAndTrainees/connectorToServer/Core/sendsystem.cpp

@@ -0,0 +1,179 @@
+#include "sendsystem.h"
+#include "tools.h"
+
+#include <QFile>
+#include <QFileInfo>
+#include <QThread>
+
+
+
+SendSystem::SendSystem(QObject *)
+{
+
+}
+
+void SendSystem::setSocket(QTcpSocket *socket)
+{
+    this->socket = socket;
+}
+
+
+void SendSystem::sendDisable()
+{
+    QDataStream stream(socket);
+    stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);
+
+    QByteArray data;
+    data = emit sigGetXmlAnswer("DISABLE");
+
+    stream << PacketType::TYPE_XMLANSWER;
+    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;
+//    stream << array;
+//    socket->waitForBytesWritten(6000);
+//}
+
+void SendSystem::sendFileBlock(QString path)
+{
+    QDataStream stream(socket);
+    stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);
+    QString fullPath = Tools::createFullPath(path);
+    quint64 fileSize = 0;
+    int countSend = 0;
+
+
+    QFile file(fullPath);       //Открываем файл для чтения
+    QFileInfo fileInfo(file);
+
+    fileSize = fileInfo.size();
+
+    stream << PacketType::TYPE_FILE; //Отправляем тип блока
+    stream << path << fileSize;
+
+    socket->waitForReadyRead(20);
+    //socket->waitForBytesWritten();
+
+    if(file.open(QFile::ReadOnly)){
+        while(!file.atEnd()){
+            QByteArray data = file.read(1025*250);
+            stream << data;
+            socket->waitForBytesWritten();
+            countSend++;
+        }
+
+        qDebug() << Tools::getTime() << "count end Final: " << countSend;
+    }
+
+    file.close();
+
+    emit sigSend();
+    //qDebug() << "Transaction after send file: " << socket->isTransactionStarted();
+    countSend = 0;
+    //socket->waitForBytesWritten();
+    socket->waitForReadyRead(20);
+}
+
+void SendSystem::sendFolderBlock(QString path)
+{
+    QDataStream stream(socket);
+    stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);
+
+    stream << PacketType::TYPE_FOLDER;
+    stream << path;
+    emit sigSend();
+    socket->waitForReadyRead(100);
+}
+
+
+void SendSystem::sendQTConnect()
+{
+    QByteArray container;
+    int numPackage = (int)PacketType::TYPE_QT;
+    container.append(numPackage & 0x000000ff);
+    container.append((numPackage >> 8) & 0x000000ff);
+    container.append((numPackage >> 16) & 0x000000ff);
+    container.append((numPackage >> 24) & 0x000000ff);
+
+    socket->write(container);
+    socket->waitForBytesWritten();
+}
+
+void SendSystem::sendXMLAnswer(QByteArray array)
+{
+    QDataStream stream(socket);
+    stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);
+
+    stream << PacketType::TYPE_XMLANSWER;
+    stream << array;
+
+    socket->waitForBytesWritten();
+    socket->waitForReadyRead(100);
+}
+
+void SendSystem::sendFinish()
+{
+    socket->waitForReadyRead(100);
+    QDataStream stream(socket);
+    stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);
+
+    stream << PacketType::TYPE_FINISH;
+    socket->waitForReadyRead(100);
+}
+
+void SendSystem::sendChangeVersion(StreamingVersionData *streamingVersion)
+{
+    QDataStream stream(socket);
+    stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);
+    stream << PacketType::CHANGE_DATA_VERSION;
+    stream << streamingVersion->getViewName();
+
+    socket->waitForReadyRead(100);
+}
+
+void SendSystem::sendDeleteVersion(StreamingVersionData *streamingVersion)
+{
+    QDataStream stream(socket);
+    stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);
+    stream << PacketType::DELETE_DATA_VERSION;
+    stream << streamingVersion->getViewName();
+
+    socket->waitForReadyRead(100);
+}
+
+void SendSystem::sendCopyVersion(QString versionName)
+{
+    QDataStream stream(socket);
+    stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);
+    stream << PacketType::COPY_VERSION;
+
+    stream << versionName;
+}
+
+void SendSystem::sendGetVersion()
+{
+    QDataStream stream(socket);
+    stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);
+    stream << PacketType::GET_VERSION;
+}
+
+void SendSystem::sendPacketType(PacketType packetType)
+{
+    QDataStream stream(socket);
+    QByteArray data;
+    stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);
+
+    stream << packetType;
+}
+SendSystem::~SendSystem()
+{
+
+}

LibInstructorsAndTrainees/connectorToServer/Core/sendsystem.h

@@ -0,0 +1,40 @@
+#ifndef SENDSYSTEM_H
+#define SENDSYSTEM_H
+
+#include <QObject>
+#include <QTcpSocket>
+#include <QDataStream>
+
+#include <streamingVersionData.h>
+#include "Core/tools.h"
+
+class SendSystem :public QObject
+{
+    Q_OBJECT
+public:
+    explicit SendSystem(QObject* parent = nullptr);
+    void setSocket(QTcpSocket *socket);
+    //void sendXMLmsgGUItoServer(QByteArray array);
+    void sendDisable();
+    void sendFileBlock(QString path);
+    void sendFolderBlock(QString path);
+    void sendQTConnect();
+    void sendXMLAnswer(QByteArray array);
+    ~SendSystem();
+    void sendFinish();    
+
+public slots:
+    void sendPacketType(PacketType packetType);
+    void sendChangeVersion(StreamingVersionData *streamingVersion);
+    void sendDeleteVersion(StreamingVersionData *streamingVersion);
+    void sendCopyVersion(QString versionName);
+    void sendGetVersion();
+signals:
+    void sigSend();
+    QByteArray sigGetXmlAnswer(QString);
+
+private:
+    QTcpSocket *socket;
+};
+
+#endif // SENDSYSTEM_H

LibInstructorsAndTrainees/connectorToServer/Core/tcpclient.cpp

@@ -0,0 +1,152 @@
+#include "tcpclient.h"
+
+#include <QDir>
+#include <QThread>
+
+TCPClient::TCPClient(QObject *parent) :
+    QObject(parent)
+{
+}
+
+void TCPClient::initialize(RecognizeSystem *recognize,SendSystem *sendSystem)
+{
+    this->recognizeSystem = recognize;
+    this->sendSystem = sendSystem;
+    isConnected = false;
+
+    emit sigSendDebugLog(Tools::getTime() + " Client started");
+}
+
+void TCPClient::setConnect(ServerSettings *serverSettings)
+{
+    socket = new QTcpSocket();
+    qDebug() << "TCPCLient thread: " << QThread::currentThreadId();
+    if (socket != NULL && socket->state() == QTcpSocket::ConnectedState)
+    {
+        emit sigSendDebugLog("already connected");
+        return;
+    }
+
+
+    socket->connectToHost(serverSettings->Address,serverSettings->Port.toShort());
+    emit sigSendDebugLog("Try connect...");
+    isConnected = true;
+
+    if (socket->waitForConnected(5))
+    {
+        connect(socket,&QTcpSocket::readyRead,this,&TCPClient::slotReadyRead,Qt::DirectConnection);
+        connect(socket,&QTcpSocket::disconnected,this,&TCPClient::setDisconnect);
+        //connect(socket,&QTcpSocket::connected,this,&TCPClient::slotConnectNotify);
+
+        connect(this,&TCPClient::sigRecognize,recognizeSystem,&RecognizeSystem::recognize,Qt::DirectConnection);
+        connect(this,&TCPClient::sigSetSocket,sendSystem,&SendSystem::setSocket);
+
+        emit sigSetSocket(socket);
+        slotConnectNotify();
+
+        emit signal_ConnectedToServer(true);
+    }
+    else
+    {
+        isConnected = false;
+        emit signal_ConnectedToServer(false);
+        emit sigServerDisconnect();
+    }
+}
+
+void TCPClient::setDisconnect()
+{
+    QDataStream stream(socket);
+    stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);
+    stream << PacketType::TYPE_DISABLE;
+
+    socket->disconnect();
+
+    isConnected = false;
+    emit sigServerDisconnect();
+    emit sigSendDebugLog("Server disabled");
+
+    emit signal_ConnectedToServer(false);
+}
+
+
+void TCPClient:: waitRead(int time)
+{
+    socket->waitForReadyRead(time);
+}
+
+QTcpSocket *TCPClient::getSocket()
+{
+    return socket;
+}
+
+void TCPClient::slotSendCommand(QString command)
+{
+    QDataStream stream(socket);
+    QByteArray data;
+    stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);
+
+    if(!command.isEmpty() && socket->state() == QTcpSocket::ConnectedState){
+
+        if(command == "check")
+        {
+            stream << PacketType::TYPE_COMMAND;
+            stream << command;
+            socket->waitForBytesWritten();
+
+            sendSystem->sendFileBlock("/" + hashFilename);
+            emit sigSendDebugLog(Tools::getTime() + " Local checkFile sended");
+
+            socket->waitForReadyRead(1000);
+        }
+        else if(command == "update"){
+            emit sigSendDebugLog("Update started");
+            stream << PacketType::TYPE_COMMAND;
+            stream << command;
+            socket->waitForReadyRead(1000);
+        }
+        else if(command == "run"){
+            //externalExecuter->callApp();
+        }
+    }else{
+        emit sigSendDebugLog("WRONG SOCKET AFTER ENTERED");
+    }
+}
+
+void TCPClient::slotConnectNotify()
+{
+    if(socket->state() != QTcpSocket::ConnectedState)
+    {
+        isConnected = false;
+        emit sigSendDebugLog("Connect invalid");
+        emit sigConnectionState(false);
+        return;
+    }
+    else
+    {
+        isConnected = true;
+        emit sigSendDebugLog("Connect complete");
+        emit sigConnectionState(true);
+        sendSystem->sendQTConnect();
+    }
+}
+
+void TCPClient::slotReadyRead()
+{
+    if(!socket){
+        emit sigSendDebugLog("WRONG SOCKET");
+        return;
+    }
+
+    emit sigRecognize(socket);
+}
+
+bool TCPClient::getIsConnected() const
+{
+    return isConnected;
+}
+
+TCPClient::~TCPClient()
+{
+
+}

LibInstructorsAndTrainees/connectorToServer/Core/tcpclient.h

@@ -0,0 +1,61 @@
+#ifndef TCPCLIENT_H
+#define TCPCLIENT_H
+
+#include <QObject>
+#include <QTcpSocket>
+#include <QHostAddress>
+#include <QDataStream>
+#include <QTcpServer>
+#include <QFile>
+#include <QCoreApplication>
+#include "Core\recognizesystem.h"
+#include "Core\tools.h"
+#include "sendsystem.h"
+#include "Datas.h"
+
+
+class RecognizeSystem;
+class SendSystem;
+
+class TCPClient : public QObject
+{
+    Q_OBJECT
+
+
+public:
+    explicit TCPClient(QObject *parent = 0);
+    void initialize(RecognizeSystem *recognize,SendSystem *sendSystem);
+    void setConnect(ServerSettings *serverSettings);
+    void setDisconnect();
+
+    void waitRead(int time);
+    QTcpSocket* getSocket();
+    ~TCPClient();
+
+    bool getIsConnected() const;
+
+signals:
+    void sigSendDebugLog(QString message);
+    void sigRecognize(QTcpSocket *socket);
+    void sigServerDisconnect();
+    void sigConnectionState(bool flag);
+    void sigSetSocket(QTcpSocket *socket);
+
+    void signal_ConnectedToServer(bool state);
+
+public slots:
+    void slotSendCommand(QString message);
+    void slotConnectNotify();
+
+private slots:
+    void slotReadyRead();
+
+
+private:
+    SendSystem *sendSystem;
+    QTcpSocket *socket;
+    RecognizeSystem *recognizeSystem;
+    bool isConnected;    
+};
+
+#endif // TCPCLIENT_H

LibInstructorsAndTrainees/connectorToServer/Core/tools.cpp

@@ -0,0 +1,58 @@
+#include "tools.h"
+
+#include <qdir.h>
+
+
+void Tools::printTime()
+{
+    qDebug() << QTime::currentTime().toString("hh:mm:ss");
+}
+
+QString Tools::getTime()
+{
+    return QTime::currentTime().toString(("hh:mm:ss"));
+}
+
+QString Tools::createLocalPath(QString path)
+{
+    qDebug() << "Full path: " << path;
+    qint8 pos = path.indexOf("Application");
+
+    QString localPath = path.remove(0,--pos);
+
+    qDebug() << "Local path: " << localPath;
+    return localPath;
+}
+
+QString Tools::createFullPath(QString path)
+{
+    QString fullPath;
+    qint8 pos = path.indexOf(additionalFilesFolderName);
+
+    QString localPath = path.remove(0,--pos);
+
+    qDebug() << "CLIENT: localPath" << localPath;
+    fullPath = QDir::currentPath() + localPath;
+
+    return fullPath;
+}
+
+QString Tools::convertFileSize(quint64 fileSize)
+{
+    quint64 megaByte = fileSize / (1024 * 1024);
+    QString resultSize;
+
+    if (megaByte == 0)
+    {
+        auto kiloByte = fileSize / 1024;
+        resultSize = QString::number(kiloByte) + "кб. ";
+    }
+    else
+    {
+        resultSize = QString::number(megaByte) + "мб. ";
+    }
+
+
+    QString result = resultSize;
+    return  result;
+}

LibInstructorsAndTrainees/connectorToServer/Core/tools.h

@@ -0,0 +1,94 @@
+#ifndef GLOBAL_H
+#define GLOBAL_H
+
+#include <QString>
+#include <QTime>
+#include <QDebug>
+
+#define TCP_READ_TIMEOUT 2000
+
+static QString applicationEXEName = "RRJ.exe";
+static QString applicationFolderName = "/Application";
+static QString staticDataFolderName = "StaticData";
+static QString additionalFilesFolderName = "RRJ-95NEW-100";
+static QString streamingAssetsPath = "/Application/RRJLoader/RRJ_Data/StreamingAssets";
+static QString hashFilename = staticDataFolderName + "/clientHash.xml";
+
+static QString configFolderName = "config";
+static QString settingsName = configFolderName + "/settings.xml";
+
+static QString tempName = staticDataFolderName + "/temp.xml";
+static QString authTempName = staticDataFolderName + "/authData.xml";
+static QString displayTemp = staticDataFolderName + "/displayData.xml";
+static QString streamingHashFilename = staticDataFolderName + "/streamingHash.xml";
+static QString serverHash = staticDataFolderName + "/serverHash.xml";
+
+static QString cmd_CheckVersionList = "CHECKVERSIONLIST";
+static QString cmd_GetOfflineMessages = "GETOFFLINEMESSAGE";
+
+enum PacketType{
+    TYPE_NONE = 0,
+    TYPE_UNITY = 1,
+    TYPE_FILE = 2,
+    TYPE_COMMAND = 3,
+    TYPE_FOLDER = 4,
+    TYPE_DELETE = 5,
+    TYPE_FINISH = 6,
+    TYPE_NEEDUPDATE = 7,
+    TYPE_XMLANSWER = 8,
+    TYPE_QT = 9,
+    TYPE_DISABLE = 11,
+    TYPE_CHECKVERSION = 13,
+    TYPE_GET_OLD_MESSAGES = 22,
+
+    TYPE_XMLANSWER_MESSAGE_FOR_GUI = 90,
+
+    //xml-ответы на запросы к БД
+    TYPE_XMLANSWER_QUERY_DB__LIST_INSTRUCTORS = 100,
+    TYPE_XMLANSWER_QUERY_DB__LIST_GROUPS = 101,
+    TYPE_XMLANSWER_QUERY_DB__LIST_TRAINEES = 102,
+    TYPE_XMLANSWER_QUERY_DB__LIST_COMPUTERS = 103,
+    TYPE_XMLANSWER_QUERY_DB__LIST_CLASSROOMS = 104,
+
+    TYPE_XMLANSWER_QUERY_TASKS_AMM_FOR_TRAINEE = 106,
+    TYPE_XMLANSWER_QUERY_TASKS_FIM_FOR_TRAINEE = 107,
+
+    //xml-ответы на запросы AdditionalFiles
+    TYPE_XMLANSWER_QUERY_TASKS_XML_FIM = 130,
+    TYPE_XMLANSWER_QUERY_TASKS_XML_AMM = 131,
+
+    //оповещение об изменении docs.xml
+    TYPE_XMLANSWER_DOCS_CHANGED = 132,
+
+    TYPE_XMLANSWER_QUERY_LIST_SUB_PROC_AMM = 133,
+
+    GET_VERSION = 149,
+    HASH_READY = 150,
+    CHANGE_DATA_VERSION = 151,
+    COPY_VERSION = 152,
+    DELETE_DATA_VERSION = 153,
+    BUSY = 154,
+    FREE = 155
+};
+
+#define NOTIFY_ERROR_AUTH_DB                "ERROR_AUTH_DB"
+#define NOTIFY_ERROR_AUTH_LOGINORPASSWORD   "ERROR_AUTH_LOGINORPASSWORD"
+#define NOTIFY_ERROR_AUTH_ARCHIVED          "ERROR_AUTH_ARCHIVED"
+#define NOTIFY_ERROR_AUTH_ALREADYLOGIN      "ERROR_AUTH_ALREADYLOGIN"
+#define NOTIFY_SERVER_END                   "END"
+#define NOTIFY_SERVER_BLOCKED               "BLOCKED"
+#define SERVER_HELLO                        "NewConnection. I am server LMS!"
+
+//Q_DECLARE_METATYPE(PacketType)
+
+class Tools {
+public:
+
+    static void printTime();
+    static QString getTime();
+    static QString createLocalPath(QString path);
+    static QString createFullPath(QString path);
+    static QString convertFileSize(quint64 fileSize);
+};
+
+#endif // GLOBAL_H

LibInstructorsAndTrainees/connectorToServer/Core/versioncontainer.cpp

@@ -0,0 +1,42 @@
+#include "versioncontainer.h"
+
+VersionContainer::VersionContainer(QObject *parent) :
+    QObject(parent)
+{
+
+}
+
+VersionContainer::~VersionContainer()
+{
+
+}
+
+QString VersionContainer::getServerVersion() const
+{
+    return serverVersionData->getViewName();
+}
+
+QString VersionContainer::getLocalVersion() const
+{
+    return localVersionData->getViewName();
+}
+
+StreamingVersionData *VersionContainer::getLocalVersionData() const
+{
+    return localVersionData;
+}
+
+void VersionContainer::setLocalVersionData(StreamingVersionData *value)
+{
+    localVersionData = value;
+}
+
+StreamingVersionData *VersionContainer::getServerVersionData() const
+{
+    return serverVersionData;
+}
+
+void VersionContainer::setServerVersionData(StreamingVersionData *value)
+{
+    serverVersionData = value;
+}

LibInstructorsAndTrainees/connectorToServer/Core/versioncontainer.h

@@ -0,0 +1,30 @@
+#ifndef VERSIONCONTAINER_H
+#define VERSIONCONTAINER_H
+
+#include <QObject>
+#include "connectorToServer/streamingversiondata.h"
+
+class VersionContainer : public QObject
+{
+    Q_OBJECT
+public:
+    explicit VersionContainer(QObject *parent = nullptr);
+    ~VersionContainer();
+
+    QString getServerVersion() const;
+    QString getLocalVersion() const;
+
+
+    StreamingVersionData *getLocalVersionData() const;
+    void setLocalVersionData(StreamingVersionData *value);
+
+    StreamingVersionData *getServerVersionData() const;
+    void setServerVersionData(StreamingVersionData *value);
+
+private:
+    StreamingVersionData *localVersionData;
+    StreamingVersionData *serverVersionData;
+
+};
+
+#endif // VERSIONCONTAINER_H