Предварительно пофиксил замирание крутилки FIM

InstructorsAndTrainees/tasks/tasktreepreparation.cpp

@@ -5,7 +5,8 @@
 
 TaskTreePreparation::TaskTreePreparation(QObject *parent) :
     QObject(parent),
-    listAllModules(nullptr),
+    listAllModulesAMM(nullptr),
+    listTaskAmmFim(nullptr),
     flagStop(false)
 {
     qDebug() << "TaskTreePreparation init thread ID " << QThread::currentThreadId();
@@ -13,7 +14,7 @@ TaskTreePreparation::TaskTreePreparation(QObject *parent) :
 
 TaskTreePreparation::~TaskTreePreparation()
 {
-    deleteAllModuls();
+    deleteAllModulsAMM();
 }
 
 void TaskTreePreparation::stopParser()
@@ -21,7 +22,7 @@ void TaskTreePreparation::stopParser()
     flagStop = true;
 }
 
-QTreeWidgetItem *TaskTreePreparation::addModuleToTreeWidget(Module *module, bool flOnlyActive, QTreeWidgetItem *parentItem)
+QTreeWidgetItem *TaskTreePreparation::addModuleToTreeWidgetAMM(Module *module, bool flOnlyActive, QTreeWidgetItem *parentItem)
 {
     QTreeWidgetItem* itemModule = nullptr;
 
@@ -48,7 +49,7 @@ QTreeWidgetItem *TaskTreePreparation::addModuleToTreeWidget(Module *module, bool
 
         for(Module* module : PMmodul->getListChildModules())
         {
-            addModuleToTreeWidget(module, flOnlyActive, itemModule);
+            addModuleToTreeWidgetAMM(module, flOnlyActive, itemModule);
         }
     }
     else
@@ -62,9 +63,9 @@ QTreeWidgetItem *TaskTreePreparation::addModuleToTreeWidget(Module *module, bool
         itemModule->setIcon(0, QIcon(":/resources/icons/procedure.png"));
     }
 
-    itemModule->setText(ColumnsTree::clmn_PMorDM, text);
-    itemModule->setText(ColumnsTree::clmn_code, code);
-    itemModule->setText(ColumnsTree::clmn_ID, ID);
+    itemModule->setText(ColumnsTreeAMM::clmnAMM_PMorDM, text);
+    itemModule->setText(ColumnsTreeAMM::clmnAMM_code, code);
+    itemModule->setText(ColumnsTreeAMM::clmnAMM_ID, ID);
     itemModule->setToolTip(0, text);
 
     return itemModule;
@@ -72,7 +73,7 @@ QTreeWidgetItem *TaskTreePreparation::addModuleToTreeWidget(Module *module, bool
 
 void TaskTreePreparation::loadAMMtasksFromXML(QByteArray array)
 {
-    deleteAllModuls();
+    deleteAllModulsAMM();
 
     QDomDocument docTasksDOM;
 
@@ -82,25 +83,117 @@ void TaskTreePreparation::loadAMMtasksFromXML(QByteArray array)
     if(manifestElement.isNull())
         return;
 
-    domElementParser(manifestElement, nullptr);
+    domElementParserAMM(manifestElement, nullptr);
 }
 
-void TaskTreePreparation::deleteAllModuls()
+void TaskTreePreparation::loadFIMtasksFromXML(QByteArray array)
 {
-    if(listAllModules == nullptr)
+    deleteAllTaskAmmFim();
+
+    QDomDocument docTasksDOM;
+
+    docTasksDOM.setContent(array);
+
+    QDomElement RRJTasksElement = docTasksDOM.firstChildElement("RRJTasks");
+    if(RRJTasksElement.isNull())
         return;
 
-    for(Module* module: *listAllModules)
+    QDomElement taskElement = RRJTasksElement.firstChildElement();
+    if(taskElement.isNull())
+        return;
+
+    do
+    {/*task*/
+        QString name = taskElement.nodeName();
+        QDomNamedNodeMap nodeMap = taskElement.attributes();
+
+        if(name == "task")
+        {
+            TaskAmmFim* task = nullptr;
+            task = new TaskAmmFim();
+
+            task->initialize(/*nodeMap.namedItem("id").nodeValue().toInt()*/ TaskAmmFim::lastID++,
+                             nodeMap.namedItem("type").nodeValue(),
+                             nodeMap.namedItem("title").nodeValue(),
+                             nodeMap.namedItem("status").nodeValue(),
+                             nodeMap.namedItem("created").nodeValue(),
+                             nodeMap.namedItem("changed").nodeValue());
+
+            QDomElement malfunctionElement = taskElement.firstChildElement();
+            if(!malfunctionElement.isNull())
+            {
+                do
+                {/*malfunction*/
+                    QString name = malfunctionElement.nodeName();
+                    QDomNamedNodeMap nodeMap = malfunctionElement.attributes();
+
+                    if(name == "malfunction")
+                    {
+                        Malfunction malfunction;
+
+                        malfunction.initialize(nodeMap.namedItem("dmCode").nodeValue(),
+                                               nodeMap.namedItem("num").nodeValue(),
+                                               nodeMap.namedItem("description").nodeValue());
+
+                        QDomElement signElement = malfunctionElement.firstChildElement();
+                        if(!signElement.isNull())
+                        {
+                            do
+                            {/*malfunctionSign*/
+                                QString name = signElement.nodeName();
+                                QDomNamedNodeMap nodeMap = signElement.attributes();
+
+                                if(name == "malfunctionSign")
+                                {
+                                    MalfunctionSign sign;
+
+                                    sign.initialize(nodeMap.namedItem("type").nodeValue().toInt(),
+                                                    nodeMap.namedItem("description").nodeValue());
+
+                                    malfunction.addMalfunctionSign(sign);
+                                }
+
+                            }while(! (signElement = signElement.nextSiblingElement()).isNull());
+                        }
+                        task->addMalfunction(malfunction);
+                    }
+                }while(! (malfunctionElement = malfunctionElement.nextSiblingElement()).isNull());
+            }
+            listTaskAmmFim->append(task);
+        }
+    }while (! (taskElement = taskElement.nextSiblingElement()).isNull());
+
+    return;
+}
+
+void TaskTreePreparation::deleteAllTaskAmmFim()
+{
+    //if(type == TypeList::listOneTask)
+        //return;
+
+    for(TaskAmmFim* task: *listTaskAmmFim)
+        delete task;
+
+    listTaskAmmFim->clear();
+}
+
+
+void TaskTreePreparation::deleteAllModulsAMM()
+{
+    if(listAllModulesAMM == nullptr)
+        return;
+
+    for(Module* module: *listAllModulesAMM)
     {
         if(module->getType() == ModuleType::TYPE_PM)
             delete static_cast<PM*>(module);
         else
             delete static_cast<DM*>(module);
     }
-    listAllModules->clear();
+    listAllModulesAMM->clear();
 }
 
-void TaskTreePreparation::domElementParser(QDomElement element, Module* moduleParent)
+void TaskTreePreparation::domElementParserAMM(QDomElement element, Module* moduleParent)
 {
     QString name;
 
@@ -200,38 +293,39 @@ void TaskTreePreparation::domElementParser(QDomElement element, Module* modulePa
 
        }
 
-        domElementParser(childElement, module);
+        domElementParserAMM(childElement, module);
 
         if(moduleParent == nullptr)
-            listAllModules->append(module);
+            listAllModulesAMM->append(module);
 
     }while (! (childElement = childElement.nextSiblingElement()).isNull());
 }
 
-void TaskTreePreparation::slot_prepareListItems(QByteArray array, QList<Module*>* listAllModules, bool flOnlyActive)
-{
-    qDebug() << "TaskTreePreparation::slot_prepareListItems thread ID " << QThread::currentThreadId();
 
-    this->listAllModules = listAllModules;
+void TaskTreePreparation::slot_prepareAMMListItems(QByteArray array, QList<Module*>* listAllModules, bool flOnlyActive)
+{
+    qDebug() << "TaskTreePreparation::slot_prepareAMMListItems thread ID " << QThread::currentThreadId();
+
+    this->listAllModulesAMM = listAllModules;
 
     loadAMMtasksFromXML(array);
 
     listItems.clear();
 
-    for(Module* module : *this->listAllModules)
+    for(Module* module : *this->listAllModulesAMM)
     {
-        QTreeWidgetItem*  item = addModuleToTreeWidget(module, flOnlyActive);
+        QTreeWidgetItem*  item = addModuleToTreeWidgetAMM(module, flOnlyActive);
         listItems.append(item);
     }
 
-    Q_EMIT signal_listItemsReady(listItems);
+    Q_EMIT signal_listAMMItemsReady(listItems);
 }
 
-void TaskTreePreparation::slot_prepareListItemsForTrainee(QList<TaskAmmFim> listTask, QList<Module *> *listAllModules)
+void TaskTreePreparation::slot_prepareAMMListItemsForTrainee(QList<TaskAmmFim> listTask, QList<Module *> *listAllModules)
 {
-    qDebug() << "TaskTreePreparation::slot_prepareListItemsForTrainee thread ID " << QThread::currentThreadId();
+    qDebug() << "TaskTreePreparation::slot_prepareAMMListItemsForTrainee thread ID " << QThread::currentThreadId();
 
-    this->listAllModules = listAllModules;
+    this->listAllModulesAMM = listAllModules;
 
     //loadAMMtasksFromList(listTask);
 
@@ -249,29 +343,29 @@ void TaskTreePreparation::slot_prepareListItemsForTrainee(QList<TaskAmmFim> list
         item = new QTreeWidgetItem();
         item->setIcon(0, QIcon(":/resources/icons/procedure.png"));
 
-        item->setText(ColumnsTree::clmn_PMorDM, text);
-        item->setText(ColumnsTree::clmn_code, code);
-        item->setText(ColumnsTree::clmn_ID, ID);        
+        item->setText(ColumnsTreeAMM::clmnAMM_PMorDM, text);
+        item->setText(ColumnsTreeAMM::clmnAMM_code, code);
+        item->setText(ColumnsTreeAMM::clmnAMM_ID, ID);
 
         if(status == "completed")
         {
-            item->setText(ColumnsTree::clmn_status, tr("completed"));
-            item->setIcon(ColumnsTree::clmn_status, QIcon(QStringLiteral(":/resources/icons/circleGreen.png")));
+            item->setText(ColumnsTreeAMM::clmnAMM_status, tr("completed"));
+            item->setIcon(ColumnsTreeAMM::clmnAMM_status, QIcon(QStringLiteral(":/resources/icons/circleGreen.png")));
         }
         else if(status == "failed")
         {
-            item->setText(ColumnsTree::clmn_status, tr("failed"));
-            item->setIcon(ColumnsTree::clmn_status, QIcon(QStringLiteral(":/resources/icons/circleRed.png")));
+            item->setText(ColumnsTreeAMM::clmnAMM_status, tr("failed"));
+            item->setIcon(ColumnsTreeAMM::clmnAMM_status, QIcon(QStringLiteral(":/resources/icons/circleRed.png")));
         }
         else if(status == "checkup")
         {
-            item->setText(ColumnsTree::clmn_status, tr("checkup"));
-            item->setIcon(ColumnsTree::clmn_status, QIcon(QStringLiteral(":/resources/icons/circleYellow.png")));
+            item->setText(ColumnsTreeAMM::clmnAMM_status, tr("checkup"));
+            item->setIcon(ColumnsTreeAMM::clmnAMM_status, QIcon(QStringLiteral(":/resources/icons/circleYellow.png")));
         }
         else
         {
-            item->setText(ColumnsTree::clmn_status, tr("new"));
-            item->setIcon(ColumnsTree::clmn_status, QIcon(QStringLiteral(":/resources/icons/circleGray.png")));
+            item->setText(ColumnsTreeAMM::clmnAMM_status, tr("new"));
+            item->setIcon(ColumnsTreeAMM::clmnAMM_status, QIcon(QStringLiteral(":/resources/icons/circleGray.png")));
         }
 
         item->setToolTip(0, text);
@@ -279,5 +373,182 @@ void TaskTreePreparation::slot_prepareListItemsForTrainee(QList<TaskAmmFim> list
         listItems.append(item);
     }
 
-    Q_EMIT signal_listItemsReady(listItems);
+    Q_EMIT signal_listAMMItemsReady(listItems);
+}
+
+void TaskTreePreparation::slot_prepareFIMListItems(QByteArray array, QList<TaskAmmFim *> *listTaskAmmFim)
+{
+    qDebug() << "TaskTreePreparation::slot_prepareFIMListItems thread ID " << QThread::currentThreadId();
+
+    this->listTaskAmmFim = listTaskAmmFim;
+
+    loadFIMtasksFromXML(array);
+
+    listItems.clear();
+
+    for(TaskAmmFim* taskPtr : *this->listTaskAmmFim)
+        {/*Задачи*/
+            TaskAmmFim task = *taskPtr;
+
+            QTreeWidgetItem* itemTask = new QTreeWidgetItem();
+
+            itemTask->setText(0, task.title);
+            itemTask->setText(1, QString::number(task.id));
+            //itemTask->setFlags(itemTask->flags() | Qt::ItemIsUserCheckable);
+            //itemTask->setCheckState(0, Qt::Checked);
+
+            if(task.status == "completed")
+            {
+                itemTask->setText(2, tr("completed"));
+                itemTask->setIcon(2, QIcon(QStringLiteral(":/resources/icons/circleGreen.png")));
+            }
+            else if(task.status == "failed")
+            {
+                itemTask->setText(2, tr("failed"));
+                itemTask->setIcon(2, QIcon(QStringLiteral(":/resources/icons/circleRed.png")));
+            }
+            else if(task.status == "checkup")
+            {
+                itemTask->setText(2, tr("checkup"));
+                itemTask->setIcon(2, QIcon(QStringLiteral(":/resources/icons/circleYellow.png")));
+            }
+            else
+            {
+                itemTask->setText(2, tr("new"));
+                itemTask->setIcon(2, QIcon(QStringLiteral(":/resources/icons/circleGray.png")));
+            }
+
+
+            itemTask->setIcon(0, QIcon(":/resources/icons/procedure.png"));
+            itemTask->setToolTip(0, task.title);
+
+            //treeWidget->addTopLevelItem(itemTask);
+
+            for (int j = 0; j < task.malfunctionList.count(); j++)
+            {/*Неисправности*/
+                Malfunction malfunction = task.malfunctionList.at(j);
+
+                QTreeWidgetItem* itemMalfunction = new QTreeWidgetItem();
+
+                itemMalfunction->setText(0, malfunction.description);
+                //if(type == TypeList::listCommon) //TODO
+                {
+                    itemMalfunction->setFlags(itemMalfunction->flags() | Qt::ItemIsUserCheckable);
+                    itemMalfunction->setCheckState(0, Qt::Checked);
+                }
+
+                itemMalfunction->setIcon(0, QIcon(":/resources/icons/malfunction.png"));
+                itemMalfunction->setToolTip(0, malfunction.description);
+
+                itemTask->addChild(itemMalfunction);
+
+                for (int k = 0; k < malfunction.malfunctionSigns.count(); k++)
+                {/*Сигнализация*/
+                    MalfunctionSign sign = malfunction.malfunctionSigns.at(k);
+
+                    QTreeWidgetItem* itemSign = new QTreeWidgetItem();
+
+                    itemSign->setText(0, sign.description);
+                    //itemSign->setFlags(itemSign->flags() | Qt::ItemIsUserCheckable);
+                    //itemSign->setCheckState(0, Qt::Checked);
+                    itemSign->setIcon(0, QIcon(":/resources/icons/sign.png"));
+                    itemSign->setToolTip(0, sign.description);
+
+                    itemMalfunction->addChild(itemSign);
+                }
+            }
+            listItems.append(itemTask);
+        }
+
+    Q_EMIT signal_listFIMItemsReady(listItems);
+}
+
+void TaskTreePreparation::slot_prepareFIMListItemsForTrainee(QList<TaskAmmFim> listTask, QList<TaskAmmFim *> *listTaskAmmFim)
+{
+    qDebug() << "TaskTreePreparation::slot_prepareFIMListItemsForTrainee thread ID " << QThread::currentThreadId();
+
+    this->listTaskAmmFim = listTaskAmmFim;
+
+    listItems.clear();
+
+    for(TaskAmmFim task : listTask)
+    {/*Задачи*/
+        //TaskAmmFim* task = listTaskAmmFim.at(i);
+        TaskAmmFim* taskNew = nullptr;
+        taskNew = new TaskAmmFim();
+        *taskNew = task;
+        this->listTaskAmmFim->append(taskNew);
+
+        QTreeWidgetItem* itemTask = new QTreeWidgetItem();
+
+        itemTask->setText(0, task.title);
+        itemTask->setText(1, QString::number(task.id));
+        //itemTask->setFlags(itemTask->flags() | Qt::ItemIsUserCheckable);
+        //itemTask->setCheckState(0, Qt::Checked);
+
+        if(task.status == "completed")
+        {
+            itemTask->setText(2, tr("completed"));
+            itemTask->setIcon(2, QIcon(QStringLiteral(":/resources/icons/circleGreen.png")));
+        }
+        else if(task.status == "failed")
+        {
+            itemTask->setText(2, tr("failed"));
+            itemTask->setIcon(2, QIcon(QStringLiteral(":/resources/icons/circleRed.png")));
+        }
+        else if(task.status == "checkup")
+        {
+            itemTask->setText(2, tr("checkup"));
+            itemTask->setIcon(2, QIcon(QStringLiteral(":/resources/icons/circleYellow.png")));
+        }
+        else
+        {
+            itemTask->setText(2, tr("new"));
+            itemTask->setIcon(2, QIcon(QStringLiteral(":/resources/icons/circleGray.png")));
+        }
+
+
+        itemTask->setIcon(0, QIcon(":/resources/icons/procedure.png"));
+        itemTask->setToolTip(0, task.title);
+
+        //treeWidget->addTopLevelItem(itemTask);
+
+        for (int j = 0; j < task.malfunctionList.count(); j++)
+        {/*Неисправности*/
+            Malfunction malfunction = task.malfunctionList.at(j);
+
+            QTreeWidgetItem* itemMalfunction = new QTreeWidgetItem();
+
+            itemMalfunction->setText(0, malfunction.description);
+            //if(type == TypeList::listCommon) //TODO
+            {
+                itemMalfunction->setFlags(itemMalfunction->flags() | Qt::ItemIsUserCheckable);
+                itemMalfunction->setCheckState(0, Qt::Checked);
+            }
+
+            itemMalfunction->setIcon(0, QIcon(":/resources/icons/malfunction.png"));
+            itemMalfunction->setToolTip(0, malfunction.description);
+
+            itemTask->addChild(itemMalfunction);
+
+            for (int k = 0; k < malfunction.malfunctionSigns.count(); k++)
+            {/*Сигнализация*/
+                MalfunctionSign sign = malfunction.malfunctionSigns.at(k);
+
+                QTreeWidgetItem* itemSign = new QTreeWidgetItem();
+
+                itemSign->setText(0, sign.description);
+                //itemSign->setFlags(itemSign->flags() | Qt::ItemIsUserCheckable);
+                //itemSign->setCheckState(0, Qt::Checked);
+                itemSign->setIcon(0, QIcon(":/resources/icons/sign.png"));
+                itemSign->setToolTip(0, sign.description);
+
+                itemMalfunction->addChild(itemSign);
+            }
+        }
+
+        listItems.append(itemTask);
+    }
+
+    Q_EMIT signal_listFIMItemsReady(listItems);
 }