Переделано под один мега-проект LMS с общим CMakeLists.txt

InstructorsAndTrainees/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)) return true;
+        return false;
+    }
+
+};   //путь
+
+struct SAttribute
+{
+    QString name;
+    QString value;
+
+};
+
+struct SXmlAnswerTag{
+    QString elementName;
+    QList<SAttribute> attr;
+};
+
+#endif // FILEDATA_H
+

InstructorsAndTrainees/connectorToServer/Core/dataparser.cpp

@@ -0,0 +1,469 @@
+#include "Core/dataparser.h"
+
+#include "FileData.h"
+#include "tools.h"
+
+#include "instructor.h"
+#include "trainee.h"
+#include "group.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();
+}
+
+void DataParser::createAuthMessage(ClientAutorization *auth)
+{
+    authPassCache = auth; //кэширование даных авторизации, для сохранения при успешном заходе
+
+    QFile file(tempName);
+    file.open(QIODevice::WriteOnly);
+    QXmlStreamWriter xmlWriter(&file);
+
+    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();
+
+    file.close();
+}
+
+void DataParser::createToClientMessage(ToClientMessage *toClientMessage)
+{
+    QFile file(tempName);
+    file.open(QIODevice::WriteOnly);
+    QXmlStreamWriter xmlWriter(&file);
+
+    xmlWriter.setAutoFormatting(true);
+    xmlWriter.writeStartDocument();
+    xmlWriter.writeStartElement("ToClientMessage");
+
+    xmlWriter.writeAttribute("id", QString::number(toClientMessage->id));
+    xmlWriter.writeAttribute("Login", toClientMessage->Login);
+    xmlWriter.writeAttribute("Text", toClientMessage->Text);
+
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndDocument();
+
+    file.close();
+}
+
+
+
+void DataParser::createQueryToDBMessage(ClientQueryToDB *queryToDB, int id, void* data)
+{
+    QFile file(tempName);
+    file.open(QIODevice::WriteOnly);
+    QXmlStreamWriter xmlWriter(&file);
+
+    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());
+            }
+        }
+    }
+
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndDocument();
+
+    file.close();
+}
+
+void DataParser::createDeAuthMessage(ClientDeAutorization *deAuth)
+{
+    QFile file(tempName);
+    file.open(QIODevice::WriteOnly);
+    QXmlStreamWriter xmlWriter(&file);
+
+    xmlWriter.setAutoFormatting(true);
+    xmlWriter.writeStartDocument();
+    xmlWriter.writeStartElement("ClientDeAutorization");
+
+    xmlWriter.writeAttribute("Login",deAuth->Login);
+
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndElement();
+    xmlWriter.writeEndDocument();
+
+    file.close();
+}
+
+
+
+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.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()
+{
+
+}

InstructorsAndTrainees/connectorToServer/Core/dataparser.h

@@ -0,0 +1,46 @@
+#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);
+    void createAuthMessage(ClientAutorization *auth);
+    void createToClientMessage(ToClientMessage *toClientMessage);
+    void createQueryToDBMessage(ClientQueryToDB *queryToDB, int id = 0, void* data = nullptr);
+    void createDeAuthMessage(ClientDeAutorization *deAuth);
+    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

InstructorsAndTrainees/connectorToServer/Core/recognizesystem.cpp

@@ -0,0 +1,556 @@
+#include "Core/recognizesystem.h"
+#include <QThread>
+#include <QDir>
+#include <QDomDocument>
+#include "instructor.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;
+        }
+
+        //xml-ответы на запросы к БД
+        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_DB__LIST_TASKS:
+            {
+                QByteArray array;
+                stream.startTransaction();
+                stream >> array;
+
+                if(!stream.commitTransaction())
+                    continue;
+
+                xmlParserQueryToDB(packetType, array);
+
+                packetType = PacketType::TYPE_NONE;
+            }
+            break;
+        };
+
+        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 == "END")
+                    {
+                        emit sigSocketDisabled();
+                    }
+
+                    if(value == "BLOCKED")
+                    {
+                        emit sigServerBlocked();
+                    }
+
+                    if(value == "HASHSENDCOMPLETE")
+                    {
+                        emit sigStartCompare();
+                    }
+                }
+            }
+        }
+
+        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;
+                }
+            }
+
+            emit sigAuth(serverAuth);
+        }
+
+        if(xmlReader.name() == "ServerMessage"){
+
+            ClientMessage *clientMessage = new ClientMessage;
+
+            foreach(const QXmlStreamAttribute &attr, xmlReader.attributes())
+            {
+                QString name = attr.name().toString();
+                QString value = attr.value().toString();
+
+                if (name == "Login"){
+                    clientMessage->Login = value;
+                }
+                if (name == "Text"){
+                    clientMessage->Text = value;
+                }
+            }
+
+            emit signal_MessageForGUI(clientMessage->Login, clientMessage->Text);
+        }
+
+        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);
+        }
+
+        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()
+
+                    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_DB__LIST_TASKS:
+        {
+            QList<Task> listTasks;
+            QDomNode listNode = commonDOM.namedItem("ListTasks");
+
+            for(int i = 0; i < listNode.childNodes().count(); i++)
+            {
+                QDomNode taskNode = listNode.childNodes().at(i);
+                if(taskNode.nodeName() == "Task")
+                {//Задача
+                    Task task;
+                    task.setID(taskNode.toElement().attribute("task_id").toInt());
+                    task.setName(taskNode.toElement().attribute("name"));
+
+                    listTasks.append(task);
+                }
+            }
+            emit sigAnswerQueryToDB_ListTasks(listTasks);
+        }
+        break;
+    };
+}
+
+void RecognizeSystem::checkAccessType(QString type)
+{
+    if(type == "instructor")
+    {
+        //mainWindow->callUpdateList();
+    }
+}

InstructorsAndTrainees/connectorToServer/Core/recognizesystem.h

@@ -0,0 +1,70 @@
+#ifndef RECOGNIZESYSTEM_H
+#define RECOGNIZESYSTEM_H
+
+#include <QObject>
+#include <QDataStream>
+#include <QTcpSocket>
+//#include <mainwindow.h>
+#include <Core\tools.h>
+#include "dataparser.h"
+#include "instructor.h"
+#include "trainee.h"
+#include "group.h"
+#include "Datas.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 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_MessageForGUI(QString login, QString text);
+
+    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_ListTasks(QList<Task> listTasks);
+
+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 checkAccessType(QString type);
+};
+
+#endif // RECOGNIZESYSTEM_H

InstructorsAndTrainees/connectorToServer/Core/sendsystem.cpp

@@ -0,0 +1,135 @@
+#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()
+{
+    QDataStream stream(socket);
+    stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);
+
+    QFile file(tempName);
+    file.open(QIODevice::ReadOnly);
+
+    QByteArray array = file.readAll();
+
+    stream << PacketType::TYPE_XMLANSWER;
+    stream << array;
+    socket->waitForBytesWritten();
+
+    file.close();
+}
+
+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()
+{
+    QString value = QString::number(PacketType::TYPE_QT);
+    socket->write(value.toUtf8());
+    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);
+}
+
+SendSystem::~SendSystem()
+{
+
+}

InstructorsAndTrainees/connectorToServer/Core/sendsystem.h

@@ -0,0 +1,31 @@
+#ifndef SENDSYSTEM_H
+#define SENDSYSTEM_H
+
+#include <QObject>
+#include <QTcpSocket>
+#include <QDataStream>
+
+class SendSystem :public QObject
+{
+    Q_OBJECT
+public:
+    explicit SendSystem(QObject* parent = nullptr);
+    void setSocket(QTcpSocket *socket);
+    void sendXMLmsgGUItoServer();
+    void sendDisable();
+    void sendFileBlock(QString path);
+    void sendFolderBlock(QString path);
+    void sendQTConnect();
+    void sendXMLAnswer(QByteArray array);
+    ~SendSystem();
+    void sendFinish();
+
+signals:
+    void sigSend();
+    QByteArray sigGetXmlAnswer(QString);
+
+private:
+    QTcpSocket *socket;
+};
+
+#endif // SENDSYSTEM_H

InstructorsAndTrainees/connectorToServer/Core/tcpclient.cpp

@@ -0,0 +1,145 @@
+#include "tcpclient.h"
+
+#include <QDir>
+
+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: " << thread();
+    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 sigServerDisconnect();
+    }
+}
+
+void TCPClient::setDisconnect()
+{
+    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()
+{
+
+}

InstructorsAndTrainees/connectorToServer/Core/tcpclient.h

@@ -0,0 +1,62 @@
+#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 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;
+
+    void setDisconnect();
+};
+
+#endif // TCPCLIENT_H

InstructorsAndTrainees/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("Application");
+
+    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;
+}

InstructorsAndTrainees/connectorToServer/Core/tools.h

@@ -0,0 +1,58 @@
+#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 streamingAssetsPath = "/Application/RRJLoader/RRJ_Data/StreamingAssets";
+static QString hashFilename = staticDataFolderName + "/clientHash.xml";
+static QString settingsName = staticDataFolderName + "/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";
+
+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_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_DB__LIST_TASKS = 105
+};
+
+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