bugFix Блочная передача больших данных

LibInstructorsAndTrainees/connectorToServer/Core/recognizesystem.cpp

@@ -294,6 +294,8 @@ void RecognizeSystem::recognize(QTcpSocket *socket)
         case TYPE_XMLANSWER_QUERY_DB__LIST_CLASSROOMS:
         case TYPE_XMLANSWER_QUERY_TASKS_AMM_FOR_TRAINEE:
         case TYPE_XMLANSWER_QUERY_TASKS_FIM_FOR_TRAINEE:
+        case TYPE_XMLANSWER_QUERY_TASKS_AMM_OF_ALL_TRAINEES:
+        case TYPE_XMLANSWER_QUERY_TASKS_FIM_OF_ALL_TRAINEES:
         case TYPE_XMLANSWER_QUERY_LIST_SUB_PROC_AMM:
             {
                 //ПОЛУЧЕНИЕ РАЗМЕРА ФАЙЛА
@@ -347,12 +349,15 @@ void RecognizeSystem::recognize(QTcpSocket *socket)
 
                     emit sigSendDebugLog(Tools::getTime() + "CLIENT: toFile :" + array.size());
 
-                    sizeReceiveData += array.size();
+                    //sizeReceiveData += array.size();
+                    sizeReceiveData = array.size();
                     countSend++;
 
                     tmpBlock.clear();
 
-                    if(sizeReceiveData == fileSize){
+                    //if(sizeReceiveData == fileSize)
+                    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));
@@ -952,6 +957,164 @@ void RecognizeSystem::xmlParserQueryToDB(PacketType packetType, QByteArray array
             emit sigAnswerQueryToDB_ListTasksFIMforTrainee(listTasks, trainee_id);
         }
         break;
+
+        case TYPE_XMLANSWER_QUERY_TASKS_AMM_OF_ALL_TRAINEES:
+        {
+            QMap<int, QList<TaskAmmFim> > mapOfLists;
+
+            QDomNode listsAllNode = commonDOM.namedItem("ListsTasksAMMofAllTrainees");
+
+            for(int i = 0; i < listsAllNode.childNodes().count(); i++)
+            {
+                QDomNode listOneNode = listsAllNode.childNodes().at(i);
+                if(listOneNode.nodeName() == "ListTasksAMM")
+                {
+                    QList<TaskAmmFim> listTasks;
+                    int trainee_id = 0;
+                    trainee_id = listOneNode.toElement().attribute("trainee_id").toInt();
+
+                    for(int i = 0; i < listOneNode.childNodes().count(); i++)
+                    {
+                        QDomNode taskNode = listOneNode.childNodes().at(i);
+                        if(taskNode.nodeName() == "taskAMM")
+                        {//Задача
+                            TaskAmmFim task;
+                            task.setID(taskNode.toElement().attribute("task_id").toInt());
+                            task.ammProcedure.title = taskNode.toElement().attribute("title");
+                            task.ammProcedure.dmCode = taskNode.toElement().attribute("dmCode");
+                            task.status = taskNode.toElement().attribute("status");
+
+                            for(int j = 0; j < taskNode.childNodes().count(); j++)
+                            {
+                                QDomNode subProcNode = taskNode.childNodes().at(j);
+                                if(subProcNode.nodeName() == "SubProc")
+                                {//Подпроцедура
+                                    SubProc subProc;
+                                    subProc.setDmCode(subProcNode.toElement().attribute("dmCode"));
+                                    subProc.setTitle(subProcNode.toElement().attribute("title"));
+                                    subProc.setModeListStr(subProcNode.toElement().attribute("canplay"));
+
+                                    task.listSubProc.append(subProc);
+                                }
+                            }
+
+                            listTasks.append(task);
+                        }
+                    }
+                    mapOfLists.insert(trainee_id, listTasks);
+                }
+            }
+
+            emit sigAnswerQueryToDB_ListsTasksAMMofAllTrainees(mapOfLists);
+        }
+        break;
+
+    case TYPE_XMLANSWER_QUERY_TASKS_FIM_OF_ALL_TRAINEES:
+    {
+        QMap<int, QList<TaskAmmFim> > mapOfLists;
+
+        QDomNode listsAllNode = commonDOM.namedItem("ListsTasksFIMofAllTrainees");
+
+        for(int i = 0; i < listsAllNode.childNodes().count(); i++)
+        {
+            QDomNode listOneNode = listsAllNode.childNodes().at(i);
+            if(listOneNode.nodeName() == "ListTasksFIM")
+            {
+                QList<TaskAmmFim> listTasks;
+                int trainee_id = 0;
+                trainee_id = listOneNode.toElement().attribute("trainee_id").toInt();
+
+                for(int i = 0; i < listOneNode.childNodes().count(); i++)
+                {//Задачи
+                    QDomNode taskNode = listOneNode.childNodes().at(i);
+                    if(taskNode.nodeName() == "taskFIM")
+                    {
+                        TaskAmmFim task;
+                        task.setID(taskNode.toElement().attribute("task_id").toInt());
+                        task.title = taskNode.toElement().attribute("title");
+                        task.status = taskNode.toElement().attribute("status");
+
+                        for(int j = 0; j < taskNode.childNodes().count(); j++)
+                        {
+                            QDomNode malfOrReportNode = taskNode.childNodes().at(j);
+                            if(malfOrReportNode.nodeName() == "malfunction")
+                            {//Неисправность
+                                Malfunction malfunction;
+                                malfunction.num = malfOrReportNode.toElement().attribute("num");
+                                malfunction.dmCode = malfOrReportNode.toElement().attribute("dmCode");
+                                malfunction.description = malfOrReportNode.toElement().attribute("description");
+                                malfunction.goName = malfOrReportNode.toElement().attribute("goName");
+                                malfunction.objName = malfOrReportNode.toElement().attribute("objName");
+
+                                for(int s = 0; s < malfOrReportNode.childNodes().count(); s++)
+                                {
+                                    QDomNode signNode = malfOrReportNode.childNodes().at(s);
+                                    if(signNode.nodeName() == "malfunctionSign")
+                                    {
+                                        MalfunctionSign sign;
+                                        sign.type = signNode.toElement().attribute("type").toInt();
+                                        sign.description = signNode.toElement().attribute("description");
+
+                                        malfunction.malfunctionSigns.append(sign);
+                                    }
+                                }
+
+                                task.malfunctionList.append(malfunction);
+                            }
+                            else
+                                if(malfOrReportNode.nodeName() == "report")
+                                {//Отчет
+                                    FIMReport report;
+                                    report.id = malfOrReportNode.toElement().attribute("report_id").toInt();
+                                    report.mmel = malfOrReportNode.toElement().attribute("mmel") == "true" ? true : false;
+
+                                    for(int k = 0; k < malfOrReportNode.childNodes().count(); k++)
+                                    {
+                                        QDomNode reportItemNode = malfOrReportNode.childNodes().at(k);
+                                        if(reportItemNode.nodeName() == "reportItem")
+                                        {
+                                            FIMReportItem reportItem;
+                                            reportItem.id = reportItemNode.toElement().attribute("item_id").toInt();
+                                            reportItem.text = reportItemNode.toElement().attribute("text");
+
+                                            if(reportItemNode.childNodes().count())
+                                            {
+                                                QDomNode procedureIDNode = reportItemNode.childNodes().at(0);
+                                                reportItem.procedure.doc = procedureIDNode.toElement().attribute("doc");
+                                                reportItem.procedure.title = procedureIDNode.toElement().attribute("title");
+                                                reportItem.procedure.dmCode = procedureIDNode.toElement().attribute("dmCode");
+                                                reportItem.procedure.result = procedureIDNode.toElement().attribute("result");
+                                            }
+
+                                            report.itemList.append(reportItem);
+                                        }
+                                        else if(reportItemNode.nodeName() == "reportWHItem")
+                                        {
+                                            FIMReportWarehouseItem reportWhItem;
+                                            reportWhItem.id = reportItemNode.toElement().attribute("wh_item_id").toInt();
+                                            reportWhItem.status = reportItemNode.toElement().attribute("status").toInt();
+                                            reportWhItem.goName = reportItemNode.toElement().attribute("goName");
+                                            reportWhItem.objName = reportItemNode.toElement().attribute("objName");
+                                            reportWhItem.code = reportItemNode.toElement().attribute("code");
+
+                                            report.warehouseItemList.append(reportWhItem);
+                                        }
+                                    }
+
+                                    task.report = report;
+                                }
+                        }
+
+                        listTasks.append(task);
+                    }
+                }
+                mapOfLists.insert(trainee_id, listTasks);
+            }
+        }
+
+        emit sigAnswerQueryToDB_ListsTasksFIMofAllTrainees(mapOfLists);
+    }
+    break;
     };
 }
 

LibInstructorsAndTrainees/connectorToServer/Core/recognizesystem.h

@@ -14,6 +14,7 @@
 #include "Datas.h"
 #include "tasksAmmFim.h"
 #include "module.h"
+#include "metatypes.h"
 
 
 class RecognizeSystem : public QObject
@@ -53,6 +54,10 @@ signals:
     void sigAnswerQueryToDB_ListClassrooms(QList<Classroom> listClassrooms);
     void sigAnswerQueryToDB_ListTasksAMMforTrainee(QList<TaskAmmFim>listTasks, int trainee_id);
     void sigAnswerQueryToDB_ListTasksFIMforTrainee(QList<TaskAmmFim>listTasks, int trainee_id);
+
+    void sigAnswerQueryToDB_ListsTasksAMMofAllTrainees(MapListsTasksAllTraineeType mapOfLists);
+    void sigAnswerQueryToDB_ListsTasksFIMofAllTrainees(MapListsTasksAllTraineeType mapOfLists);
+
     void sigAnswerQueryTasksXML_FIM(QByteArray array);
     void sigAnswerQueryTasksXML_AMM(QByteArray array);
     void sigShowServerDataList(QList<StreamingVersionData*> *versions);

LibInstructorsAndTrainees/connectorToServer/Core/tools.h

@@ -53,6 +53,9 @@ enum PacketType{
     TYPE_XMLANSWER_QUERY_TASKS_AMM_FOR_TRAINEE = 106,
     TYPE_XMLANSWER_QUERY_TASKS_FIM_FOR_TRAINEE = 107,
 
+    TYPE_XMLANSWER_QUERY_TASKS_AMM_OF_ALL_TRAINEES = 108,
+    TYPE_XMLANSWER_QUERY_TASKS_FIM_OF_ALL_TRAINEES = 109,
+
     //xml-ответы на запросы AdditionalFiles
     TYPE_XMLANSWER_QUERY_TASKS_XML_FIM = 130,
     TYPE_XMLANSWER_QUERY_TASKS_XML_AMM = 131,

LibInstructorsAndTrainees/connectorToServer/connectortoserver.cpp

@@ -167,6 +167,9 @@ void ConnectorToServer::bindConnection()
     connect(recognizeSystem,&RecognizeSystem::sigAnswerQueryToDB_ListTasksAMMforTrainee,this,&ConnectorToServer::slot_AnswerQueryToDB_ListTasksAMMforTrainee);
     connect(recognizeSystem,&RecognizeSystem::sigAnswerQueryToDB_ListTasksFIMforTrainee,this,&ConnectorToServer::slot_AnswerQueryToDB_ListTasksFIMforTrainee);
 
+    connect(recognizeSystem,&RecognizeSystem::sigAnswerQueryToDB_ListsTasksAMMofAllTrainees,this,&ConnectorToServer::slot_AnswerQueryToDB_ListsTasksAMMofAllTrainees);
+    connect(recognizeSystem,&RecognizeSystem::sigAnswerQueryToDB_ListsTasksFIMofAllTrainees,this,&ConnectorToServer::slot_AnswerQueryToDB_ListsTasksFIMofAllTrainees);
+
     connect(recognizeSystem,&RecognizeSystem::sigAnswerQueryTasksXML_FIM,this,&ConnectorToServer::slot_AnswerQueryTasksXML_FIM);
     connect(recognizeSystem,&RecognizeSystem::sigAnswerQueryTasksXML_AMM,this,&ConnectorToServer::slot_AnswerQueryTasksXML_AMM);
 

LibInstructorsAndTrainees/connectorToServer/connectortoserver.h

@@ -15,6 +15,7 @@
 #include "classroom.h"
 #include "Datas.h"
 #include "streamingversiondata.h"
+#include "metatypes.h"
 
 class ConnectorToServer : public QObject
 {
@@ -97,6 +98,10 @@ public slots:
     void slot_AnswerQueryToDB_ListClassrooms(QList<Classroom> listClassrooms);
     void slot_AnswerQueryToDB_ListTasksAMMforTrainee(QList<TaskAmmFim> listTasks, int trainee_id);
     void slot_AnswerQueryToDB_ListTasksFIMforTrainee(QList<TaskAmmFim> listTasks, int trainee_id);
+
+    void slot_AnswerQueryToDB_ListsTasksAMMofAllTrainees(MapListsTasksAllTraineeType mapOfLists);
+    void slot_AnswerQueryToDB_ListsTasksFIMofAllTrainees(MapListsTasksAllTraineeType mapOfLists);
+
     void slot_AnswerQueryTasksXML_FIM(QByteArray array);
     void slot_AnswerQueryTasksXML_AMM(QByteArray array);
     void slot_AnswerQuerySubProc(QList<SubProc> listSubProc, QString parentTask_dmCode);

LibInstructorsAndTrainees/connectorToServer/connectortoserver_AnswerQueryToDB.cpp

@@ -95,6 +95,46 @@ void ConnectorToServer::slot_AnswerQueryToDB_ListTasksFIMforTrainee(QList<TaskAm
     emit signal_UpdateDB(false, true);
 }
 
+void ConnectorToServer::slot_AnswerQueryToDB_ListsTasksAMMofAllTrainees(MapListsTasksAllTraineeType mapOfLists)
+{
+    mtxAccess.lock();
+
+    for(int key : mapOfLists.keys())
+    {
+        //Удаляем старые задачи этого обучаемого
+        mapTasksAMM.remove(key);
+
+        //Добавляем новые
+        mapTasksAMM.insert(key, mapOfLists.value(key));
+
+        emit signal_UpdateTasksAMMforTrainee(key);
+    }
+
+    mtxAccess.unlock();
+
+    emit signal_UpdateDB(false, true);
+}
+
+void ConnectorToServer::slot_AnswerQueryToDB_ListsTasksFIMofAllTrainees(MapListsTasksAllTraineeType mapOfLists)
+{
+    mtxAccess.lock();
+
+    for(int key : mapOfLists.keys())
+    {
+        //Удаляем старые задачи этого обучаемого
+        mapTasksFIM.remove(key);
+
+        //Добавляем новые
+        mapTasksFIM.insert(key, mapOfLists.value(key));
+
+        emit signal_UpdateTasksFIMforTrainee(key);
+    }
+
+    mtxAccess.unlock();
+
+    emit signal_UpdateDB(false, true);
+}
+
 void ConnectorToServer::slot_AnswerQueryTasksXML_FIM(QByteArray array)
 {
     mtxAccess.lock();

LibInstructorsAndTrainees/metatypes.cpp

@@ -1,5 +1,7 @@
 #include "metatypes.h"
 
+
+
 void registerMetaType()
 {
     qRegisterMetaType<QList<Instructor>>("QList<Instructor>");
@@ -9,9 +11,16 @@ void registerMetaType()
     qRegisterMetaType<QList<Classroom>>("QList<Classroom>");
     qRegisterMetaType<QList<Module*>>("QList<Module*>");
     qRegisterMetaType<QList<TaskAmmFim>>("QList<TaskAmmFim>");
+    //qRegisterMetaType<QMap<int, QList<TaskAmmFim>>>("QMap<int, QList<TaskAmmFim>>");
+
+
+    qRegisterMetaType<MapListsTasksAllTraineeType>("MapListsTasksAllTraineeType");
+
     qRegisterMetaType<PacketType>("PacketType");
     qRegisterMetaType<ClientMessage>("ClientMessage");
     qRegisterMetaType<QList<QTreeWidgetItem*>>("QList<QTreeWidgetItem*>");
 
     qRegisterMetaType<QList<SubProc>>("QList<SubProc>");
+
+    qRegisterMetaType<QMap<int, float>>("QMap<int, float>");
 }

LibInstructorsAndTrainees/metatypes.h

@@ -2,6 +2,7 @@
 #define METATYPES_H
 
 #include <QTreeWidgetItem>
+#include <QMap>
 
 #include "instructor.h"
 #include "trainee.h"
@@ -13,6 +14,8 @@
 #include "tools.h"
 #include "Datas.h"
 
+typedef QMap<int, QList<TaskAmmFim>> MapListsTasksAllTraineeType;
+
 void registerMetaType();
 
 Q_DECLARE_METATYPE(QList<Instructor>)
@@ -26,6 +29,8 @@ Q_DECLARE_METATYPE(PacketType)
 Q_DECLARE_METATYPE(ClientMessage)
 Q_DECLARE_METATYPE(QList<QTreeWidgetItem*>)
 
+Q_DECLARE_METATYPE(MapListsTasksAllTraineeType)
+
 Q_DECLARE_METATYPE(QList<SubProc>)
 
 #endif // METATYPES_H

LibServer/Data/PacketType.h

@@ -37,6 +37,9 @@ enum PacketType
     TYPE_XMLANSWER_QUERY_TASKS_AMM_OF_TRAINEE = 106,
     TYPE_XMLANSWER_QUERY_TASKS_FIM_OF_TRAINEE = 107,
 
+    TYPE_XMLANSWER_QUERY_TASKS_AMM_OF_ALL_TRAINEES = 108,
+    TYPE_XMLANSWER_QUERY_TASKS_FIM_OF_ALL_TRAINEES = 109,
+
     //xml-ответы на запросы AdditionalFiles
     TYPE_XMLANSWER_QUERY_TASKS_XML_FIM = 130,
     TYPE_XMLANSWER_QUERY_TASKS_XML_AMM = 131,

LibServer/Server.qrc

@@ -19,5 +19,7 @@
         <file>resources/icons/save.png</file>
         <file>resources/icons/stoped.png</file>
         <file>resources/blankXML/ListCFI.xml</file>
+        <file>resources/blankXML/ListsTasksAMMofAllTrainees.xml</file>
+        <file>resources/blankXML/ListsTasksFIMofAllTrainees.xml</file>
     </qresource>
 </RCC>

LibServer/Systems/Parsers/dbanswerparser.cpp

@@ -261,3 +261,136 @@ QByteArray DBAnswerParser::listTasksFIMofTrainee(bool result, QList<TaskAmmFim>
 
     return commonDOM.toByteArray();
 }
+
+QByteArray DBAnswerParser::listsTasksAMMofAllTrainees(QMap<int, QList<TaskAmmFim> > *mapOfLists)
+{
+    QDomDocument commonDOM;
+    if(! Tools::loadFileXMLtoDOM(":/resources/blankXML/ListsTasksAMMofAllTrainees.xml", &commonDOM))
+        return QByteArray();
+
+    QDomNode listsAllNode = commonDOM.namedItem("ListsTasksAMMofAllTrainees");
+
+    for(int key : mapOfLists->keys())
+    {
+        QList<TaskAmmFim> listOne = mapOfLists->value(key);
+
+        QDomNode listOneNode = commonDOM.createElement("ListTasksAMM");
+        listsAllNode.appendChild(listOneNode);
+
+        listOneNode.toElement().setAttribute("trainee_id", QString::number(key));
+
+        for(TaskAmmFim task : listOne)
+        {
+            //Задача
+            QDomNode taskNode = commonDOM.createElement("taskAMM");
+            listOneNode.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::saveDOMtoFileXML("ListsTasksAMMofAllTrainees.xml", &commonDOM);
+
+    return commonDOM.toByteArray();
+}
+
+QByteArray DBAnswerParser::listsTasksFIMofAllTrainees(QMap<int, QList<TaskAmmFim> > *mapOfLists)
+{
+    QDomDocument commonDOM;
+    if(! Tools::loadFileXMLtoDOM(":/resources/blankXML/ListsTasksFIMofAllTrainees.xml", &commonDOM))
+        return QByteArray();
+
+    QDomNode listsAllNode = commonDOM.namedItem("ListsTasksFIMofAllTrainees");
+
+    for(int key : mapOfLists->keys())
+    {
+        QList<TaskAmmFim> listOne = mapOfLists->value(key);
+
+        QDomNode listOneNode = commonDOM.createElement("ListTasksFIM");
+        listsAllNode.appendChild(listOneNode);
+
+        listOneNode.toElement().setAttribute("trainee_id", QString::number(key));
+
+        for(TaskAmmFim task : listOne)
+        {
+            //Задача
+            QDomNode taskNode = commonDOM.createElement("taskFIM");
+            listOneNode.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);
+                malfunctionNode.toElement().setAttribute("goName", malfunction.goName);
+                malfunctionNode.toElement().setAttribute("objName", malfunction.objName);
+
+                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);
+                reportNode.toElement().setAttribute("mmel", report.mmel ? "true" : "false");
+
+                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);
+                }
+
+                for(FIMReportWarehouseItem reportWhItem : task.report.warehouseItemList)
+                {//FIMReportWarehouseItem
+                    QDomNode reportWhItemNode = commonDOM.createElement("reportWHItem");
+                    reportNode.appendChild(reportWhItemNode);
+                    reportWhItemNode.toElement().setAttribute("wh_item_id", reportWhItem.id);
+                    reportWhItemNode.toElement().setAttribute("status", reportWhItem.status);
+                    reportWhItemNode.toElement().setAttribute("goName", reportWhItem.goName);
+                    reportWhItemNode.toElement().setAttribute("objName", reportWhItem.objName);
+                    reportWhItemNode.toElement().setAttribute("code", reportWhItem.code);
+                }
+            }
+        }
+    }
+
+    Tools::saveDOMtoFileXML("ListsTasksFIMofAllTrainees.xml", &commonDOM);
+
+    return commonDOM.toByteArray();
+}

LibServer/Systems/Parsers/dbanswerparser.h

@@ -23,6 +23,9 @@ public:
 
     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);
+
+    QByteArray listsTasksAMMofAllTrainees(QMap<int, QList<TaskAmmFim> > *mapOfLists);
+    QByteArray listsTasksFIMofAllTrainees(QMap<int, QList<TaskAmmFim> > *mapOfLists);
 signals:
 
 private:

LibServer/Systems/processingsystem.cpp

@@ -2,6 +2,7 @@
 #include "providerdblms.h"
 
 #include <clienthandler.h>
+#include <QMap>
 
 ProcessingSystem::ProcessingSystem(ProviderDBLMS* providerDBLMS, UpdateController* updateController, DocsUpdater* docsUpdater, CfiController* cfiController, QObject *parent):
     QObject(parent),
@@ -322,14 +323,21 @@ void ProcessingSystem::processingClientQueryToDB(ClientHandler *client, ClientQu
             //client->sendXmlAnswer(arrayAnswer, PacketType::TYPE_XMLANSWER_QUERY_DB__LIST_TRAINEES);
             client->sendFileBlockByteArray(arrayAnswer, PacketType::TYPE_XMLANSWER_QUERY_DB__LIST_TRAINEES);
 
-            /**/
+            if(listTrainees.count())
+            {
+                //Отправка списка задач FIM всех обучаемых клиенту GUI
+                sendListsTasksFIMofAllTraineestoClient(client, listTrainees);
+                //Отправка списка задач AMM всех обучаемых клиенту GUI
+                sendListsTasksAMMofAllTraineestoClient(client, listTrainees);
+            }
+            /*
             for(Trainee trainee : listTrainees)
             {
                 //Отправка списка задач AMM этого обучаемого клиенту GUI
                 sendListTasksAMMofTraineetoClient(client, trainee.getID());
                 //Отправка списка задач FIM этого обучаемого клиенту GUI
                 sendListTasksFIMofTraineetoClient(client, trainee.getID());
-            }
+            }*/
 
             break;
         }
@@ -756,6 +764,36 @@ void ProcessingSystem::sendListTasksFIMofTraineetoClient(ClientHandler *client,
     client->sendFileBlockByteArray(arrayAnswer, PacketType::TYPE_XMLANSWER_QUERY_TASKS_FIM_OF_TRAINEE);
 }
 
+void ProcessingSystem::sendListsTasksAMMofAllTraineestoClient(ClientHandler *client, QList<Trainee> listTrainees)
+{
+    QMap<int, QList<TaskAmmFim>> mapOfLists;
+    for(Trainee trainee : listTrainees)
+    {
+        int id_trainee = trainee.getID();
+        QList<TaskAmmFim> listTasksOneTrainee = providerDBLMS->GetListTasksAMMofTrainee(id_trainee);
+        if(listTasksOneTrainee.count())
+            mapOfLists.insert(id_trainee, listTasksOneTrainee);
+    }
+
+    QByteArray arrayAnswer = dataParser->DbAnswer()->listsTasksAMMofAllTrainees(&mapOfLists);
+    client->sendFileBlockByteArray(arrayAnswer, PacketType::TYPE_XMLANSWER_QUERY_TASKS_AMM_OF_ALL_TRAINEES);
+}
+
+void ProcessingSystem::sendListsTasksFIMofAllTraineestoClient(ClientHandler *client, QList<Trainee> listTrainees)
+{
+    QMap<int, QList<TaskAmmFim>> mapOfLists;
+    for(Trainee trainee : listTrainees)
+    {
+        int id_trainee = trainee.getID();
+        QList<TaskAmmFim> listTasksOneTrainee = providerDBLMS->GetListTasksFIMofTrainee(id_trainee);
+        if(listTasksOneTrainee.count())
+            mapOfLists.insert(id_trainee, listTasksOneTrainee);
+    }
+
+    QByteArray arrayAnswer = dataParser->DbAnswer()->listsTasksFIMofAllTrainees(&mapOfLists);
+    client->sendFileBlockByteArray(arrayAnswer, PacketType::TYPE_XMLANSWER_QUERY_TASKS_FIM_OF_ALL_TRAINEES);
+}
+
 void ProcessingSystem::sendListTasksAMMofTraineeByIDtoClient(ClientHandler *client, int id_trainee, QList<int> listID)
 {
     QList<TaskAmmFim> listTasksNeed;

LibServer/Systems/processingsystem.h

@@ -50,6 +50,10 @@ public:
     void sendListTasksAMMofTraineetoClient(ClientHandler* client, int id_trainee);
     void sendListTasksFIMofTraineetoClient(ClientHandler* client, int id_trainee);
 
+    void sendListsTasksAMMofAllTraineestoClient(ClientHandler *client, QList<Trainee> listTrainees);
+    void sendListsTasksFIMofAllTraineestoClient(ClientHandler* client, QList<Trainee> listTrainees);
+
+
     void sendListTasksAMMofTraineeByIDtoClient(ClientHandler* client, int id_trainee, QList<int> listID);
     void sendListTasksFIMofTraineeByIDtoClient(ClientHandler* client, int id_trainee, QList<int> listID);
 

LibServer/Systems/sendsystem.cpp

@@ -85,7 +85,7 @@ void SendSystem::sendFileBlockByteArray(QByteArray array, PacketType packetType)
         QDataStream stream(socket);
         stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);
 
-        quint64 size = array.size();
+        qint64 size = array.size();
         qint64 bytesSended = 0;
 
         if (size == 0)
@@ -97,19 +97,20 @@ void SendSystem::sendFileBlockByteArray(QByteArray array, PacketType packetType)
          stream << packetType; //Отправляем тип блока
          stream << size;
 
-         while (size > 0)
+         //while (size > 0)
+         while (bytesSended < size)
          {
              QByteArray chunk = array.mid(bytesSended,sendFileBlockSize);
              stream << chunk;
 
              bytesSended += chunk.length();
-             size -= bytesSended;
+             //size -= bytesSended;
          }
     }
     else
     {
          sendPacketType(packetType);
-         quint64 size = array.size();
+         qint64 size = array.size();
          qint64 bytesSended = 0;
 
          if (size == 0)

LibServer/resources/blankXML/ListsTasksAMMofAllTrainees.xml

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ListsTasksAMMofAllTrainees>
+</ListsTasksAMMofAllTrainees>

LibServer/resources/blankXML/ListsTasksFIMofAllTrainees.xml

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ListsTasksFIMofAllTrainees>
+</ListsTasksFIMofAllTrainees>