refact1

LibServer/Systems/Parsers/clientanswerparser.cpp

@@ -0,0 +1,127 @@
+#include "clientanswerparser.h"
+
+ClientAnswerParser::ClientAnswerParser(QObject *parent) : QObject(parent)
+{
+
+}
+
+void ClientAnswerParser::initialize(DataParser *dataParser)
+{
+    this->dataParser = dataParser;
+}
+
+QByteArray ClientAnswerParser::authorization(bool result, QString instructorName,QString clientName, QString accessType, QString login, int id)
+{
+
+    QList<SXmlAnswerTag> listTag;
+
+    SAttribute attribute1 = {"Result", result? "true" : "false"};
+    SAttribute attribute2 = {"InstructorName", instructorName};
+    SAttribute attribute3 = {"ClientName", clientName};
+    SAttribute attribute4 = {"AccessType", accessType};
+    SAttribute attribute5 = {"Login", login};
+    SAttribute attribute6 = {"id_client", QString::number(id)};
+    QList<SAttribute> listAttr = {attribute1, attribute2, attribute3, attribute4, attribute5, attribute6};
+    SXmlAnswerTag tag = {"ServerAuthorization", listAttr};
+
+    listTag.append(tag);
+
+    return dataParser->xmlAnswer(listTag);
+}
+
+QByteArray ClientAnswerParser::deAuthorization(bool result, QString login)
+{
+    QList<SXmlAnswerTag> listTag;
+
+    SAttribute attribute1 = {"Result", result? "true" : "false"};
+    SAttribute attribute2 = {"Login", login};
+    QList<SAttribute> listAttr = {attribute1, attribute2};
+    SXmlAnswerTag tag = {"ServerDeAuthorization", listAttr};
+
+    listTag.append(tag);
+
+    return dataParser->xmlAnswer(listTag);
+}
+
+QByteArray ClientAnswerParser::message(QString loginFrom,QString loginTo,QString text)
+{
+    QList<SXmlAnswerTag> listTag;
+    QList<SAttribute> listAttr;
+    SAttribute attribute1;
+    attribute1 = {"From",loginFrom};
+    listAttr.append(attribute1);
+    attribute1 = {"To",loginTo};
+    listAttr.append(attribute1);
+    attribute1 = {"Text",text};
+    listAttr.append(attribute1);
+
+    SXmlAnswerTag tag = {"ClientMessage", listAttr};
+
+    listTag.append(tag);
+
+    return dataParser->xmlAnswer(listTag);
+}
+
+QByteArray ClientAnswerParser::task(QString text)
+{
+    QList<SXmlAnswerTag> listTag;
+
+    SAttribute attribute1 = {"Text", text};
+    QList<SAttribute> listAttr = {attribute1};
+    SXmlAnswerTag tag = {"ServerTask", listAttr};
+
+    listTag.append(tag);
+
+    return dataParser->xmlAnswer(listTag);
+}
+
+QByteArray ClientAnswerParser::notify(QString code)
+{
+    QList<SXmlAnswerTag> listTag;
+
+    SAttribute attribute1 = {"Code", code};
+    QList<SAttribute> listAttr = {attribute1};
+    SXmlAnswerTag tag = {"ServerNotify", listAttr};
+
+    listTag.append(tag);
+
+    return dataParser->xmlAnswer(listTag);
+}
+
+QByteArray ClientAnswerParser::tasks(QStringList listTasks)
+{
+    QList<SXmlAnswerTag> listTag;
+
+    foreach(QString task, listTasks)
+    {
+        QList<SAttribute> listAttr;
+
+        SAttribute attribute1 = {"Head", task};
+        SAttribute attribute2 = {"IsComplete", "false"};
+        listAttr.append(attribute1);
+        listAttr.append(attribute2);
+
+        SXmlAnswerTag tag = {"ServerTask", listAttr};
+        listTag.append(tag);
+    }
+
+    return dataParser->xmlAnswer(listTag, "TaskArray", "Tasks");
+}
+
+QByteArray ClientAnswerParser::currentVersion()
+{
+    QByteArray array;
+    QFile fileR(version);
+    if (!fileR.open(QFile::ReadOnly | QFile::Text))
+    {
+        QString str = "Не удалось открыть файл";
+        qDebug() << "xmlAnswer: " << str;
+    }
+    else
+    {
+        array = fileR.readAll();
+        fileR.close();   // Закрываем файл
+    }
+
+    return array;
+}

LibServer/Systems/Parsers/clientanswerparser.h

@@ -0,0 +1,30 @@
+#ifndef CLIENTANSWERPARSER_H
+#define CLIENTANSWERPARSER_H
+
+#include <QObject>
+
+#include <Systems/Parsers/dataparser.h>
+#include <Data/typesDataServerClient.h>
+
+
+class ClientAnswerParser : public QObject
+{
+    Q_OBJECT
+public:
+    explicit ClientAnswerParser(QObject *parent = nullptr);
+    void initialize(DataParser *dataParser);
+
+    QByteArray authorization(bool result, QString instructorName, QString clientName, QString accessType, QString login, int id);
+    QByteArray deAuthorization(bool result, QString login);
+    QByteArray message(QString loginFrom,QString loginTo,QString text);
+    QByteArray task(QString text);
+    QByteArray notify(QString code);
+    QByteArray tasks(QStringList listTasks);
+    QByteArray currentVersion();
+signals:
+
+private:
+    DataParser *dataParser;
+};
+
+#endif // CLIENTANSWERPARSER_H

LibServer/Systems/Parsers/dataparser.cpp

@@ -0,0 +1,139 @@
+#include "dataparser.h"
+
+#include <QFile>
+#include <QDomDocument>
+
+DataParser::DataParser(AssetsManager *assetManager,ProcessingSystem *processingSystem,QObject *parent) :
+QObject(parent)
+{
+    this->processingSystem = processingSystem;
+    this->assetsManager = assetManager;
+
+    clientAnswer = new ClientAnswerParser;
+    clientAnswer->initialize(this);
+
+    dbAnswer = new DBAnswerParser;
+    dbAnswer->initialize(this);
+
+    docsAnswer = new DocsAnswerParser;
+
+    processParser = new ProcessParser;
+    processParser->initialize(processingSystem);
+
+    mutex = new QMutex;
+
+    qDebug() << "ParserThread: " << QThread::currentThreadId();
+}
+
+
+
+QByteArray DataParser::xmlAnswer(QList<SXmlAnswerTag> listTag, QString elemUp1, QString elemUp2)
+{
+    try {
+
+        mutex->lock();
+        /* Открываем файл для Записи*/
+        QFile file(tempFile);
+        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;
+
+        array = readTempFile();
+        mutex->unlock();
+
+        return array;
+    }
+    catch(const std::exception& e)
+
+    {
+        qDebug() << e.what();
+        return nullptr;
+    }
+
+
+}
+
+QByteArray DataParser::readTempFile()
+{
+    QByteArray array;
+    QFile fileR(tempFile);
+    if (!fileR.open(QFile::ReadOnly | QFile::Text))
+    {
+        QString str = "Не удалось открыть файл";
+        qDebug() << "xmlAnswer: " << str;
+    }
+    else
+    {
+        array = fileR.readAll();
+        fileR.close();
+    }
+
+    return array;
+}
+
+ClientAnswerParser *DataParser::ClientAnswer() const
+{
+    return clientAnswer;
+}
+
+DBAnswerParser *DataParser::DbAnswer() const
+{
+    return dbAnswer;
+}
+
+ProcessParser *DataParser::getProcessParser() const
+{
+    return processParser;
+}
+
+DocsAnswerParser *DataParser::getDocsAnswerParser() const
+{
+    return docsAnswer;
+}
+
+DataParser::~DataParser()
+{
+    delete clientAnswer;
+    delete dbAnswer;
+    delete docsAnswer;
+    delete processParser;
+    delete mutex;
+}
+
+

LibServer/Systems/Parsers/dataparser.h

@@ -0,0 +1,64 @@
+#ifndef DATAPARSER_H
+#define DATAPARSER_H
+
+#include "Systems/processingsystem.h"
+#include "Systems/tools.h"
+#include "Systems/assetsmanager.h"
+#include "Systems/logger.h"
+#include "Systems/Parsers/clientanswerparser.h"
+#include "dbanswerparser.h"
+#include "docsanswerparser.h"
+#include "processparser.h"
+#include "serverlmswidget.h"
+
+#include <QByteArray>
+#include <QXmlStreamReader>
+#include <QDebug>
+#include <QDomDocument>
+
+#include <Data/typesDataServerClient.h>
+#include <Data/StreamingVersionData.h>
+
+class ProcessingSystem;
+class ClientHandler;
+class AssetsManager;
+class ClientAnswerParser;
+class DBAnswerParser;
+class DocsAnswerParser;
+class ProcessParser;
+
+class DataParser : public QObject
+{
+
+  Q_OBJECT
+public:
+    DataParser(AssetsManager *assetManager,ProcessingSystem *processingSystem,QObject* parent = nullptr);
+    void xmlParser(ClientHandler *client, QByteArray array);
+    void xmlFileDataParse(QByteArray array);
+
+    QByteArray xmlAnswer(QList<SXmlAnswerTag> listTag,QString elemUp1 = "", QString elemUp2 = "");
+
+    ~DataParser();
+
+    ClientAnswerParser *ClientAnswer() const;
+    DBAnswerParser *DbAnswer() const;
+    ProcessParser *getProcessParser() const;
+    DocsAnswerParser *getDocsAnswerParser() const;
+
+signals:
+    void sigLogMessage(QString log);
+
+
+private:
+    QMutex *mutex;
+
+    ProcessingSystem *processingSystem;
+    AssetsManager *assetsManager;
+    ClientAnswerParser *clientAnswer;
+    DBAnswerParser *dbAnswer;
+    DocsAnswerParser* docsAnswer;
+    ProcessParser *processParser;
+    QByteArray readTempFile();
+};
+
+#endif // DATAPARSER_H

LibServer/Systems/Parsers/dbanswerparser.cpp

@@ -0,0 +1,249 @@
+#include "dbanswerparser.h"
+
+
+
+DBAnswerParser::DBAnswerParser(QObject *parent) : QObject(parent)
+{
+
+}
+
+void DBAnswerParser::initialize(DataParser *dataParser)
+{
+    this->dataParser = dataParser;
+}
+
+QByteArray DBAnswerParser::listInstructors(bool result, QList<Instructor> *listInstructors)
+{
+    QDomDocument commonDOM;
+    if(! Tools::loadXMLtoDOM(":/resources/blankXML/ListInstructors.xml", &commonDOM))
+        return QByteArray();
+
+    QDomNode listNode = commonDOM.namedItem("ListInstructors");
+
+    for(Instructor instructor : *listInstructors)
+    {
+        //Инструктор
+        QDomNode instructorNode = commonDOM.createElement("Instructor");
+        listNode.appendChild(instructorNode);
+        instructorNode.toElement().setAttribute("instructor_id", QString::number(instructor.getID()));
+        instructorNode.toElement().setAttribute("name", instructor.getName());
+        instructorNode.toElement().setAttribute("login", instructor.getLogin());
+        instructorNode.toElement().setAttribute("password", instructor.getPassword());
+        instructorNode.toElement().setAttribute("is_admin", instructor.getIsAdmin());
+        instructorNode.toElement().setAttribute("archived", instructor.getArchived());
+        instructorNode.toElement().setAttribute("logged_in", instructor.getLoggedIn());
+    }
+
+    Tools::saveDOMtoXML("ListInstructors.xml", &commonDOM);
+
+    return commonDOM.toByteArray();
+}
+
+QByteArray DBAnswerParser::listGroups(bool result, QList<Group> *listGroups)
+{
+    QDomDocument commonDOM;
+    if(! Tools::loadXMLtoDOM(":/resources/blankXML/ListGroups.xml", &commonDOM))
+        return QByteArray();
+
+    QDomNode listNode = commonDOM.namedItem("ListGroups");
+
+    for(Group group : *listGroups)
+    {
+        //Группа
+        QDomNode groupNode = commonDOM.createElement("Group");
+        listNode.appendChild(groupNode);
+        groupNode.toElement().setAttribute("group_id", QString::number(group.getID()));
+        groupNode.toElement().setAttribute("name", group.getName());
+    }
+
+    Tools::saveDOMtoXML("ListGroups.xml", &commonDOM);
+
+    return commonDOM.toByteArray();
+}
+
+QByteArray DBAnswerParser::listTrainees(bool result, QList<Trainee> *listTrainees)
+{
+    QDomDocument commonDOM;
+    if(! Tools::loadXMLtoDOM(":/resources/blankXML/ListTrainees.xml", &commonDOM))
+        return QByteArray();
+
+    QDomNode listNode = commonDOM.namedItem("ListTrainees");
+
+    for(Trainee trainee : *listTrainees)
+    {
+        //Обучаемый
+        QDomNode traineeNode = commonDOM.createElement("Trainee");
+        listNode.appendChild(traineeNode);
+        traineeNode.toElement().setAttribute("trainee_id", trainee.getID());
+        traineeNode.toElement().setAttribute("name", trainee.getName());
+        traineeNode.toElement().setAttribute("login", trainee.getLogin());
+        traineeNode.toElement().setAttribute("password", trainee.getPassword());
+        traineeNode.toElement().setAttribute("archived", trainee.getArchived());
+        traineeNode.toElement().setAttribute("logged_in", trainee.getLoggedIn());
+        traineeNode.toElement().setAttribute("group_trainee", trainee.getGroup().getID());
+        traineeNode.toElement().setAttribute("computer_trainee", trainee.getComputer().getID());
+        //trainee.setTasks()
+
+        //Тайминг
+        QDomNode timingNode = commonDOM.createElement("timing");
+        traineeNode.appendChild(timingNode);
+
+        TimingOfTrainee timing = trainee.getTiming();
+
+        timingNode.toElement().setAttribute("entryTime", timing.getEntryTimeS());
+        timingNode.toElement().setAttribute("exitTime", timing.getExitTimeS());
+        timingNode.toElement().setAttribute("operatingTime", timing.getOperatingTimeS());
+    }
+
+    Tools::saveDOMtoXML("ListTrainees.xml", &commonDOM);
+
+    return commonDOM.toByteArray();
+}
+
+QByteArray DBAnswerParser::listComputers(bool result, QList<Computer> *listComputers)
+{
+    //TODO
+    return QByteArray();
+}
+
+QByteArray DBAnswerParser::listClassrooms(bool result, QList<Classroom> *listClassrooms)
+{
+    //TODO
+    return QByteArray();
+}
+
+QByteArray DBAnswerParser::listContacts(bool result, QList<ContactModel> *listContacts)
+{
+    QDomDocument doc;
+    QDomProcessingInstruction xmlDecl = doc.createProcessingInstruction("xml", "version='1.0' encoding='utf-8'");
+    doc.insertBefore(xmlDecl,doc.firstChild());
+    QDomElement root = doc.createElement("ContactArray");
+
+    for(ContactModel entity : *listContacts)
+    {
+        QDomElement contact = doc.createElement("ContactData");
+        contact.toElement().setAttribute("name",entity.getName());
+        contact.toElement().setAttribute("id",entity.getID());
+        QString isLogged = entity.getLoggedIn() ? "1" : "0";
+        contact.toElement().setAttribute("isOnline",isLogged);
+        contact.toElement().setAttribute("UserType",entity.getType());
+        contact.toElement().setAttribute("Login",entity.getLogin());
+
+        root.appendChild(contact);
+    }
+
+    doc.appendChild(root);
+
+    qDebug() << doc.toString();
+    return doc.toByteArray();
+
+}
+
+QByteArray DBAnswerParser::listTasksAMMofTrainee(bool result, QList<TaskAmmFim> *listTasks, int trainee_id, bool full_list)
+{
+    QDomDocument commonDOM;
+    if(! Tools::loadXMLtoDOM(":/resources/blankXML/ListTasksAMM.xml", &commonDOM))
+        return QByteArray();
+
+    QDomNode listNode = commonDOM.namedItem("ListTasksAMM");
+    listNode.toElement().setAttribute("trainee_id", QString::number(trainee_id));
+    if(full_list)
+        listNode.toElement().setAttribute("full_list", "true");
+    else
+        listNode.toElement().setAttribute("full_list", "false");
+
+    for(TaskAmmFim task : *listTasks)
+    {
+        //Задача
+        QDomNode taskNode = commonDOM.createElement("taskAMM");
+        listNode.appendChild(taskNode);
+        taskNode.toElement().setAttribute("task_id", QString::number(task.getID()));
+        taskNode.toElement().setAttribute("title", task.ammProcedure.title);
+        taskNode.toElement().setAttribute("dmCode", task.ammProcedure.dmCode);
+        taskNode.toElement().setAttribute("status", task.status);
+
+        for(SubProc subProc : task.listSubProc)
+        {//Подпроцедура
+            QDomNode subProcNode = commonDOM.createElement("SubProc");
+            taskNode.appendChild(subProcNode);
+
+            subProcNode.toElement().setAttribute("dmCode", subProc.getDmCode());
+            subProcNode.toElement().setAttribute("title", subProc.getTitle());
+            subProcNode.toElement().setAttribute("canplay", subProc.getModeListStr());
+        }
+    }
+
+    Tools::saveDOMtoXML("ListTasksAMM.xml", &commonDOM);
+
+    return commonDOM.toByteArray();
+}
+
+QByteArray DBAnswerParser::listTasksFIMofTrainee(bool result, QList<TaskAmmFim> *listTasks, int trainee_id, bool full_list)
+{
+    QDomDocument commonDOM;
+    if(! Tools::loadXMLtoDOM(":/resources/blankXML/ListTasksFIM.xml", &commonDOM))
+        return QByteArray();
+
+    QDomNode listNode = commonDOM.namedItem("ListTasksFIM");
+    listNode.toElement().setAttribute("trainee_id", QString::number(trainee_id));
+    if(full_list)
+        listNode.toElement().setAttribute("full_list", "true");
+    else
+        listNode.toElement().setAttribute("full_list", "false");
+
+    for(TaskAmmFim task : *listTasks)
+    {
+        //Задача
+        QDomNode taskNode = commonDOM.createElement("taskFIM");
+        listNode.appendChild(taskNode);
+        taskNode.toElement().setAttribute("task_id", QString::number(task.getID()));
+        taskNode.toElement().setAttribute("title", task.title);
+        taskNode.toElement().setAttribute("status", task.status);
+
+        for(Malfunction malfunction : task.malfunctionList)
+        {//Неисправность
+            QDomNode malfunctionNode = commonDOM.createElement("malfunction");
+            taskNode.appendChild(malfunctionNode);
+            malfunctionNode.toElement().setAttribute("dmCode", malfunction.dmCode);
+            malfunctionNode.toElement().setAttribute("num", malfunction.num);
+            malfunctionNode.toElement().setAttribute("description", malfunction.description);
+
+            for(MalfunctionSign sign : malfunction.malfunctionSigns)
+            {//Сигналы
+                QDomNode signNode = commonDOM.createElement("malfunctionSign");
+                malfunctionNode.appendChild(signNode);
+                signNode.toElement().setAttribute("type", sign.type);
+                signNode.toElement().setAttribute("description", sign.description);
+            }
+        }
+
+
+        {//FIMReport
+            FIMReport report = task.report;
+            QDomNode reportNode = commonDOM.createElement("report");
+            taskNode.appendChild(reportNode);
+            reportNode.toElement().setAttribute("report_id", report.id);
+
+            for(FIMReportItem reportItem : task.report.itemList)
+            {//FIMReportItem
+                QDomNode reportItemNode = commonDOM.createElement("reportItem");
+                reportNode.appendChild(reportItemNode);
+                reportItemNode.toElement().setAttribute("item_id", reportItem.id);
+                reportItemNode.toElement().setAttribute("text", reportItem.text);
+
+                //ProcedureID
+                QDomNode procedureIDNode = commonDOM.createElement("procedureID");
+                reportItemNode.appendChild(procedureIDNode);
+
+                procedureIDNode.toElement().setAttribute("doc", reportItem.procedure.doc);
+                procedureIDNode.toElement().setAttribute("title", reportItem.procedure.title);
+                procedureIDNode.toElement().setAttribute("dmCode", reportItem.procedure.dmCode);
+                procedureIDNode.toElement().setAttribute("result", reportItem.procedure.result);
+            }
+        }
+    }
+
+    Tools::saveDOMtoXML("ListTasksFIM.xml", &commonDOM);
+
+    return commonDOM.toByteArray();
+}

LibServer/Systems/Parsers/dbanswerparser.h

@@ -0,0 +1,33 @@
+#ifndef DBANSWERPARSER_H
+#define DBANSWERPARSER_H
+
+#include "dataparser.h"
+#include "serverlmswidget.h"
+
+#include <QObject>
+#include <QDomDocument>
+#include <contactModel.h>
+
+class DBAnswerParser : public QObject
+{
+    Q_OBJECT
+public:
+    explicit DBAnswerParser(QObject *parent = nullptr);
+    void initialize(DataParser *dataParser);
+    QByteArray listInstructors(bool result, QList<Instructor> *listInstructors);
+    QByteArray listGroups(bool result, QList<Group> *listGroups);
+    QByteArray listTrainees(bool result, QList<Trainee> *listTrainees);
+    QByteArray listComputers(bool result, QList<Computer> *listComputers);
+    QByteArray listClassrooms(bool result, QList<Classroom> *listClassrooms);
+    QByteArray listContacts(bool result, QList<ContactModel> *listContacts);
+
+    QByteArray listTasksAMMofTrainee(bool result, QList<TaskAmmFim> *listTasks, int trainee_id, bool full_list);
+    QByteArray listTasksFIMofTrainee(bool result, QList<TaskAmmFim> *listTasks, int trainee_id, bool full_list);
+signals:
+
+private:
+    DataParser *dataParser;
+
+};
+
+#endif // DBANSWERPARSER_H

LibServer/Systems/Parsers/docsanswerparser.cpp

@@ -0,0 +1,30 @@
+#include "docsanswerparser.h"
+#include "docsupdater.h"
+
+DocsAnswerParser::DocsAnswerParser(QObject *parent) : QObject(parent)
+{
+
+}
+
+QByteArray DocsAnswerParser::listSubProc(QList<SubProc> list, QString dmCode)
+{
+    QDomDocument commonDOM;
+    if(! Tools::loadXMLtoDOM(":/resources/blankXML/ListSubProc.xml", &commonDOM))
+        return QByteArray();
+
+    QDomNode listNode = commonDOM.namedItem("ListSubProc");
+    listNode.toElement().setAttribute("dmCode", dmCode);
+
+    for(SubProc subProc : list)
+    {
+        QDomNode subProcNode = commonDOM.createElement("SubProc");
+        listNode.appendChild(subProcNode);
+        subProcNode.toElement().setAttribute("dmCode", subProc.getDmCode());
+        subProcNode.toElement().setAttribute("title", subProc.getTitle());
+        subProcNode.toElement().setAttribute("canplay", subProc.getModeListStr());
+    }
+
+    Tools::saveDOMtoXML("ListSubProc.xml", &commonDOM);
+
+    return commonDOM.toByteArray();
+}

LibServer/Systems/Parsers/docsanswerparser.h

@@ -0,0 +1,23 @@
+#ifndef DOCSANSWERPARSER_H
+#define DOCSANSWERPARSER_H
+
+#include <QObject>
+#include <QList>
+#include "docsupdater.h"
+
+struct SubProc;
+
+class DocsAnswerParser : public QObject
+{
+    Q_OBJECT
+public:
+    explicit DocsAnswerParser(QObject *parent = nullptr);
+
+public:
+    QByteArray listSubProc(QList<SubProc> list, QString dmCode);
+
+signals:
+
+};
+
+#endif // DOCSANSWERPARSER_H

LibServer/Systems/Parsers/processparser.cpp

@@ -0,0 +1,606 @@
+#include "processparser.h"
+#include "tasksAmmFim.h"
+
+ProcessParser::ProcessParser(QObject *parent) : QObject(parent) //TODO: переименовать в XMLProcessParser?
+{
+
+}
+
+void ProcessParser::initialize(ProcessingSystem *processingSystem)
+{
+    this->processingSystem = processingSystem;
+}
+
+void ProcessParser::slot_read(ClientHandler *client, QByteArray array)
+{
+    QXmlStreamReader xmlReader(array);
+
+    xmlReader.readNext();   // Переходим к первому элементу в файле
+
+    //Крутимся в цикле до тех пор, пока не достигнем конца документа
+    while(!xmlReader.atEnd())
+    {
+        //Проверяем, является ли элемент началом тега
+        if(xmlReader.isStartElement())
+        {
+            //Анализируем теги
+            if(xmlReader.name() == "ClientAutorization")
+            {//Запрос авторизации от клиента
+
+                clientAuth(xmlReader,client);
+            }
+            else if(xmlReader.name() == "ClientDeAutorization")
+            {//Запрос ДеАвторизации от клиента
+
+                clientDeAuth(xmlReader,client);
+            }
+            else if(xmlReader.name() == "QueryToDB")
+            {//Запрос к базе данных от клиента
+
+                queryToDb(xmlReader,client, array);
+            }
+            else if(xmlReader.name() == "QueryTasksXML")
+            {//Запрос файла XML с задачами
+
+                queryTasksXML(xmlReader,client);
+            }
+            else if(xmlReader.name() == "QueryListSubProc")
+            {//Запрос списка подпроцедур
+
+                queryListSubProc(xmlReader,client);
+            }
+            else if(xmlReader.name() == "ClientMessage")
+            {//Сообщение от клиента
+
+                clientMessage(xmlReader,client);
+            }
+            else if(xmlReader.name() == "ClientNotify")
+            {//Уведомление от клиента
+
+                clientNotify(xmlReader,client);
+            }
+            else if(xmlReader.name() == "DataInfo")
+            {
+                  clientDataInfo(xmlReader,client);
+            }
+            else if(xmlReader.name() == "ListTasksAMM")
+            {
+                if(client->getClient()->getClientType() == TypeClientAutorization::TYPE_UNITY_CLIENT)
+                {//Отчет по задаче АММ от Юнити-клиента
+                    clientUnityTaskAMMreport(xmlReader,client, array);
+                }
+            }
+            else if(xmlReader.name() == "ListTasksFIM")
+            {
+                if(client->getClient()->getClientType() == TypeClientAutorization::TYPE_UNITY_CLIENT)
+                {//Отчет по задаче FIM от Юнити-клиента
+                    clientUnityTaskFIMreport(xmlReader,client, array);
+                }
+            }
+            else if(xmlReader.name() == "BlockAuth")
+            {//Запрос Блокировки Авторизации от клиента ГУИ
+
+                clientBlockAuth(xmlReader,client);
+            }
+            else
+            {
+                emit sigLogMessage("XmlParser: unrecognized tag");
+            }
+
+        }
+        xmlReader.readNext(); // Переходим к следующему элементу файла
+    }//while(!xmlReader.atEnd())
+}
+
+void ProcessParser::clientDataInfo(QXmlStreamReader &xmlReader,ClientHandler *client)
+{
+    DataInfo *dataInfo = new DataInfo;
+
+    foreach(const QXmlStreamAttribute &attr, xmlReader.attributes())
+    {
+        QString name = attr.name().toString();
+        QString value = attr.value().toString();
+
+        if(name == "path")
+            dataInfo->path= value.toUtf8();
+
+        if(name == "size")
+            dataInfo->size = value.toLong();
+    }
+
+    processingSystem->setCurrentDataInfo(dataInfo);
+
+}
+
+void ProcessParser::clientUnityTaskAMMreport(QXmlStreamReader &xmlReader, ClientHandler *client, QByteArray array)
+{
+    QDomDocument commonDOM;
+    commonDOM.setContent(array);
+
+    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");
+
+            listTasks.append(task);
+
+            //Изменение задачи
+            void* data = nullptr;
+            data = &task;
+            ClientQueryToDB queryToDB;
+            queryToDB.typeQuery = TypeQueryToDB::TYPE_QUERY_SET_REPORT_TASK_AMM_TO_TRAINEE;
+            processingSystem->processingClientQueryToDB(client, queryToDB, trainee_id, data);
+        }
+    }
+
+    emit processingSystem->sigStatusTasksAMMofTraineeChanged(trainee_id);
+}
+
+void ProcessParser::clientUnityTaskFIMreport(QXmlStreamReader &xmlReader, ClientHandler *client, QByteArray array)
+{
+    QDomDocument commonDOM;
+    commonDOM.setContent(array);
+
+    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 = malfunctionNode.toElement().attribute("num");
+                    malfunction.dmCode = malfunctionNode.toElement().attribute("dmCode");
+                    malfunction.description = malfunctionNode.toElement().attribute("description");
+
+                    task.malfunctionList.append(malfunction);
+                    */
+                }
+                else
+                    if(malfOrReportNode.nodeName() == "report")
+                    {//Отчет
+                        FIMReport report;
+                        report.id = 0; //malfOrReportNode.toElement().attribute("report_id").toInt();
+
+                        for(int k = 0; k < malfOrReportNode.childNodes().count(); k++)
+                        {
+                            QDomNode reportItemNode = malfOrReportNode.childNodes().at(k);
+                            if(reportItemNode.nodeName() == "item")
+                            {
+                                FIMReportItem reportItem;
+                                reportItem.id = 0; //reportItemNode.toElement().attribute("item_id").toInt();
+                                reportItem.text = reportItemNode.toElement().attribute("title");
+
+                                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;
+                    }
+            }
+            /*
+
+            //TODO -------------- (!Заглушка!) Отчет о выполнении
+            FIMReport report;
+            FIMReportItem reportItem;
+            QString text;             // текст, вводимый обучаемым
+            ProcedureID procedure;   // ссылка на процедуру, при необходимости
+
+            text = "1. Выполнил такую процедуру";
+            procedure.doc = "fim";
+            procedure.title = "Процедура №1";
+            procedure.dmCode = "RRJ-N-27-92-00-51D01-420A-A";
+            procedure.result = "viewed";
+            reportItem.text = text;
+            reportItem.procedure = procedure;
+            report.itemList.append(reportItem);
+
+            text = "2. Выполнил такую процедуру";
+            procedure.doc = "fim";
+            procedure.title = "Процедура №2";
+            procedure.dmCode = "RRJ-N-28-22-00-01A01-420A-A";
+            procedure.result = "viewed";
+            reportItem.text = text;
+            reportItem.procedure = procedure;
+            report.itemList.append(reportItem);
+
+            task.report = report;
+            //-----------------
+            */
+
+
+            listTasks.append(task);
+
+            //Изменение задачи
+            void* data = nullptr;
+            data = &task;
+            ClientQueryToDB queryToDB;
+            queryToDB.typeQuery = TypeQueryToDB::TYPE_QUERY_SET_REPORT_TASK_FIM_TO_TRAINEE;
+            processingSystem->processingClientQueryToDB(client, queryToDB, trainee_id, data);
+        }
+    }
+
+    emit processingSystem->sigStatusTasksFIMofTraineeChanged(trainee_id);
+}
+
+TaskAmmFim ProcessParser::xmlParserQueryToDB_ASSIGN_TASK_FIM_TO_TRAINEE(QByteArray array)
+{
+    TaskAmmFim task;
+
+    QDomDocument commonDOM;
+    commonDOM.setContent(array);
+
+    QDomNode mainNode = commonDOM.namedItem("QueryToDB");
+
+    task.title = mainNode.toElement().attribute("title");
+
+    for(int i = 0; i < mainNode.childNodes().count(); i++)
+    {
+        QDomNode malfunctionNode = mainNode.childNodes().at(i);
+        if(malfunctionNode.nodeName() == "malfunction")
+        {//Неисправность
+            Malfunction malfunction;
+
+            malfunction.num = malfunctionNode.toElement().attribute("num");
+            malfunction.dmCode = malfunctionNode.toElement().attribute("dmCode");
+            malfunction.description = malfunctionNode.toElement().attribute("description");
+
+            //Сигналы
+            for(int j = 0; j < malfunctionNode.childNodes().count(); j++)
+            {
+                QDomNode signNode = malfunctionNode.childNodes().at(j);
+                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);
+        }
+    }
+
+    return task;
+}
+
+TaskAmmFim ProcessParser::xmlParserQueryToDB_ASSIGN_TASK_AMM_TO_TRAINEE(QByteArray array)
+{
+    TaskAmmFim task;
+
+    QDomDocument commonDOM;
+    commonDOM.setContent(array);
+
+    QDomNode mainNode = commonDOM.namedItem("QueryToDB");
+
+    task.ammProcedure.title = mainNode.toElement().attribute("title");
+    task.ammProcedure.dmCode = mainNode.toElement().attribute("dmCode");
+
+    for(int i = 0; i < mainNode.childNodes().count(); i++)
+    {
+        QDomNode subProcNode = mainNode.childNodes().at(i);
+        if(subProcNode.nodeName() == "SubProc")
+        {//Подпроцедура
+            SubProc subProc;
+
+            subProc.setTitle(subProcNode.toElement().attribute("title"));
+            subProc.setDmCode(subProcNode.toElement().attribute("dmCode"));
+            subProc.setModeListStr(subProcNode.toElement().attribute("canplay"));
+
+            task.listSubProc.append(subProc);
+        }
+    }
+
+    return task;
+}
+
+void ProcessParser::clientAuth(QXmlStreamReader &xmlReader,ClientHandler *client)
+{
+    ClientAutorization clientAutorization;
+
+    /*Перебираем все атрибуты тега*/
+    foreach(const QXmlStreamAttribute &attr, xmlReader.attributes())
+    {
+        QString name = attr.name().toString();
+        QString value = attr.value().toString();
+        //addTextToLogger(name + ": " + value);
+
+        if(name == "Login")
+            clientAutorization.Login = value;
+        else if(name == "Password")
+            clientAutorization.Password = value;
+        else if(name == "NumberOfScreen")
+            clientAutorization.NumberOfScreen = value.toInt();
+        else if(name == "TypeClient")
+            clientAutorization.TypeClient = (TypeClientAutorization)value.toInt();
+    }
+
+    processingSystem->processingClientAutorization(client, clientAutorization);
+}
+
+void ProcessParser::clientDeAuth(QXmlStreamReader &xmlReader,ClientHandler *client)
+{
+    ClientDeAutorization clientDeAutorization;
+
+    /*Перебираем все атрибуты тега*/
+    foreach(const QXmlStreamAttribute &attr, xmlReader.attributes())
+    {
+        QString name = attr.name().toString();
+        QString value = attr.value().toString();
+        //addTextToLogger(name + ": " + value);
+
+        if(name == "Login")
+            clientDeAutorization.Login = value;
+    }
+
+    processingSystem->processingClientDeAutorization(client, clientDeAutorization);
+}
+
+void ProcessParser::clientBlockAuth(QXmlStreamReader &xmlReader, ClientHandler *client)
+{
+    bool block = false;
+
+    /*Перебираем все атрибуты тега*/
+    foreach(const QXmlStreamAttribute &attr, xmlReader.attributes())
+    {
+        QString name = attr.name().toString();
+        QString value = attr.value().toString();
+        //addTextToLogger(name + ": " + value);
+
+        if(name == "Block")
+            block = (value == "1") ? true : false;
+    }
+
+    processingSystem->processingClientBlockAuth(client, block);
+}
+
+void ProcessParser::queryToDb(QXmlStreamReader &xmlReader,ClientHandler *client, QByteArray array)
+{
+    ClientQueryToDB queryToDB;
+    int id = 0;
+    Instructor instructor;
+    Trainee trainee;
+    Group group;
+    TaskAmmFim task;
+    QString status = "";
+    void* data = nullptr;
+
+    /*Перебираем все атрибуты тега*/
+    foreach(const QXmlStreamAttribute &attr, xmlReader.attributes())
+    {
+        QString name = attr.name().toString();
+        QString value = attr.value().toString();
+        //addTextToLogger(name + ": " + value);
+
+        if(name == "TypeQuery")
+        {
+            queryToDB.typeQuery = (TypeQueryToDB)value.toInt();
+            if(queryToDB.typeQuery == TypeQueryToDB::TYPE_QUERY_ASSIGN_TASK_FIM_TO_TRAINEE)
+            {
+                task = xmlParserQueryToDB_ASSIGN_TASK_FIM_TO_TRAINEE(array);
+            }
+            else if(queryToDB.typeQuery == TypeQueryToDB::TYPE_QUERY_ASSIGN_TASK_AMM_TO_TRAINEE)
+            {
+                task = xmlParserQueryToDB_ASSIGN_TASK_AMM_TO_TRAINEE(array);
+            }
+        }
+        else if(name == "id")
+            id = value.toInt();
+        else
+        {
+            switch (queryToDB.typeQuery)
+            {
+            case TypeQueryToDB::TYPE_QUERY_NEW_INSTRUCTOR:
+            case TypeQueryToDB::TYPE_QUERY_EDIT_INSTRUCTOR:
+                if(name == "instructor_id")
+                    instructor.setID(value.toInt());
+                else if(name == "name")
+                    instructor.setName(value);
+                else if(name == "login")
+                    instructor.setLogin(value);
+                else if(name == "password")
+                    instructor.setPassword(value);
+                else if(name == "is_admin")
+                    instructor.setIsAdmin(value.toInt());
+                else if(name == "archived")
+                    instructor.setArchived(value.toInt());
+                else if(name == "logged_in")
+                    instructor.setLoggedIn(value.toInt());
+                break;
+            case TypeQueryToDB::TYPE_QUERY_NEW_TRAINEE:
+            case TypeQueryToDB::TYPE_QUERY_EDIT_TRAINEE:
+                if(name == "trainee_id")
+                    trainee.setID(value.toInt());
+                else if(name == "name")
+                    trainee.setName(value);
+                else if(name == "login")
+                    trainee.setLogin(value);
+                else if(name == "password")
+                    trainee.setPassword(value);
+                else if(name == "archived")
+                    trainee.setArchived(value.toInt());
+                else if(name == "logged_in")
+                    trainee.setLoggedIn(value.toInt());
+                else if(name == "group_trainee")
+                {
+                    Group group(value.toInt(), "");
+                    trainee.setGroup(group);
+                }
+                else if(name == "computer_trainee")
+                {
+                    Computer computer(value.toInt(), "", "", Classroom());
+                    trainee.setComputer(computer);
+                }
+                break;
+            case TypeQueryToDB::TYPE_QUERY_NEW_GROUP:
+            case TypeQueryToDB::TYPE_QUERY_EDIT_GROUP:
+                if(name == "group_id")
+                    group.setID(value.toInt());
+                else if(name == "name")
+                    group.setName(value);
+                break;
+
+            case TypeQueryToDB::TYPE_QUERY_ASSIGN_TASK_AMM_TO_TRAINEE:
+                /*
+                if(name == "title")
+                    task.ammProcedure.title = value;
+                else if(name == "dmCode")
+                    task.ammProcedure.dmCode = value;
+                    */
+                break;
+            case TypeQueryToDB::TYPE_QUERY_ASSIGN_TASK_FIM_TO_TRAINEE:
+                //if(name == "title")
+                    //task.title = value;
+                break;
+
+            case TypeQueryToDB::TYPE_QUERY_CHANGE_STATUS_REPORT_TASK_AMM_TO_TRAINEE:
+            case TypeQueryToDB::TYPE_QUERY_CHANGE_STATUS_REPORT_TASK_FIM_TO_TRAINEE:
+                if(name == "status")
+                    status = value;
+                break;
+            };
+        }
+    }
+
+    switch (queryToDB.typeQuery)
+    {
+    case TypeQueryToDB::TYPE_QUERY_NEW_INSTRUCTOR:
+    case TypeQueryToDB::TYPE_QUERY_EDIT_INSTRUCTOR:
+        data = &instructor;
+        break;
+    case TypeQueryToDB::TYPE_QUERY_NEW_TRAINEE:
+    case TypeQueryToDB::TYPE_QUERY_EDIT_TRAINEE:
+        data = &trainee;
+        break;
+    case TypeQueryToDB::TYPE_QUERY_NEW_GROUP:
+    case TypeQueryToDB::TYPE_QUERY_EDIT_GROUP:
+        data = &group;
+        break;
+    case TypeQueryToDB::TYPE_QUERY_ASSIGN_TASK_AMM_TO_TRAINEE:
+    case TypeQueryToDB::TYPE_QUERY_ASSIGN_TASK_FIM_TO_TRAINEE:
+        data = &task;
+        break;
+    case TypeQueryToDB::TYPE_QUERY_CHANGE_STATUS_REPORT_TASK_AMM_TO_TRAINEE:
+    case TypeQueryToDB::TYPE_QUERY_CHANGE_STATUS_REPORT_TASK_FIM_TO_TRAINEE:
+        data = &status;
+        break;
+    };
+
+    processingSystem->processingClientQueryToDB(client, queryToDB, id, data);
+}
+
+void ProcessParser::queryTasksXML(QXmlStreamReader &xmlReader, ClientHandler *client)
+{
+    ClientQueryTasksXML clientQueryTasksXML;
+
+    /*Перебираем все атрибуты тега*/
+    foreach(const QXmlStreamAttribute &attr, xmlReader.attributes())
+    {
+        QString name = attr.name().toString();
+        QString value = attr.value().toString();
+        //addTextToLogger(name + ": " + value);
+
+        if(name == "Type")
+            clientQueryTasksXML.Type = value;
+    }
+
+    processingSystem->processingClientQueryTasksXML(client, clientQueryTasksXML);
+}
+
+void ProcessParser::queryListSubProc(QXmlStreamReader &xmlReader, ClientHandler *client)
+{
+    QString dmCode = "";
+
+    /*Перебираем все атрибуты тега*/
+    foreach(const QXmlStreamAttribute &attr, xmlReader.attributes())
+    {
+        QString name = attr.name().toString();
+        QString value = attr.value().toString();
+        //addTextToLogger(name + ": " + value);
+
+        if(name == "dmCode")
+            dmCode = value;
+    }
+
+    processingSystem->processingClientQueryListSubProc(client, dmCode);
+}
+
+void ProcessParser::clientMessage(QXmlStreamReader &xmlReader,ClientHandler *client)
+{
+    ClientMessage clientMessage;
+
+    /*Перебираем все атрибуты тега*/
+    foreach(const QXmlStreamAttribute &attr, xmlReader.attributes())
+    {
+        QString name = attr.name().toString();
+        QString value = attr.value().toString();
+        //addTextToLogger(name + ": " + value);
+
+        if (name == "Text")
+            clientMessage.Text = value;
+        if (name == "From")
+            clientMessage.From = value;
+        if (name == "To")
+            clientMessage.To = value;
+    }
+
+    processingSystem->processingSendMessage(clientMessage);
+
+}
+
+void ProcessParser::clientNotify(QXmlStreamReader &xmlReader,ClientHandler *client)
+{
+    ClientNotify clientNotify;
+
+    /*Перебираем все атрибуты тега*/
+    foreach(const QXmlStreamAttribute &attr, xmlReader.attributes())
+    {
+        QString name = attr.name().toString();
+        QString value = attr.value().toString();
+
+        if(name == "Code")
+            clientNotify.Code = value;
+    }
+
+    processingSystem->processingClientNotify(client, clientNotify);
+}
+
+

LibServer/Systems/Parsers/processparser.h

@@ -0,0 +1,43 @@
+#ifndef PROCESSPARSER_H
+#define PROCESSPARSER_H
+
+#include <QObject>
+#include <qxmlstream.h>
+#include <clienthandler.h>
+#include "Data/typesDataServerClient.h"
+
+class ProcessParser : public QObject
+{
+    Q_OBJECT
+public:
+    explicit ProcessParser(QObject *parent = nullptr);
+    void initialize(ProcessingSystem *processingSystem);
+
+public slots:
+    void slot_read(ClientHandler *client, QByteArray array);
+
+signals:
+    void sigLogMessage(QString text);
+
+    //void sigStatusTasksAMMofTraineeChanged(int trainee_id);
+    //void sigStatusTasksFIMofTraineeChanged(int trainee_id);
+private:
+    ProcessingSystem *processingSystem;
+    void clientAuth(QXmlStreamReader &xmlReader,ClientHandler *client);
+    void clientDeAuth(QXmlStreamReader &xmlReader,ClientHandler *client);
+    void clientBlockAuth(QXmlStreamReader &xmlReader,ClientHandler *client);
+    void toClientMessage(QXmlStreamReader &xmlReader,ClientHandler *client);
+    void queryToDb(QXmlStreamReader &xmlReader,ClientHandler *client, QByteArray array = QByteArray());
+    void queryTasksXML(QXmlStreamReader &xmlReader,ClientHandler *client);
+    void queryListSubProc(QXmlStreamReader &xmlReader,ClientHandler *client);
+    void clientMessage(QXmlStreamReader &xmlReader,ClientHandler *client);
+    void clientNotify(QXmlStreamReader &xmlReader,ClientHandler *client);
+    void clientDataInfo(QXmlStreamReader &xmlReader, ClientHandler *client);
+    void clientUnityTaskAMMreport(QXmlStreamReader &xmlReader,ClientHandler *client, QByteArray array = QByteArray());
+    void clientUnityTaskFIMreport(QXmlStreamReader &xmlReader,ClientHandler *client, QByteArray array = QByteArray());
+
+    TaskAmmFim xmlParserQueryToDB_ASSIGN_TASK_FIM_TO_TRAINEE(QByteArray array);
+    TaskAmmFim xmlParserQueryToDB_ASSIGN_TASK_AMM_TO_TRAINEE(QByteArray array);
+};
+
+#endif // PROCESSPARSER_H