RRJServer/InstructorsAndTrainees/tasks/ammtaskswidget.cpp

#include <QFile>
#include <QXmlStreamReader>
#include <QDomDocument>
#include <QMessageBox>
#include <QThread>
#include <QResizeEvent>
#include "ammtaskswidget.h"
#include "ui_ammtaskswidget.h"

AMMtasksWidget::AMMtasksWidget(ConnectorToServer* connectorToServer, QWidget *parent) :
    QWidget(parent),
    ui(new Ui::AMMtasksWidget),
    connectorToServer(connectorToServer),
    loginTraineeSelected("")
{
    ui->setupUi(this);

    treeWidget = new QTreeWidget();
    ui->horizontalLayout_1->addWidget(treeWidget);

    connect(treeWidget, &QTreeWidget::currentItemChanged, this, &AMMtasksWidget::on_treeWidget_currentItemChanged);

    preparationTreeWidget();

    ui->btnAssignTaskToTrainee->setEnabled(false);

    qDebug() << "AMMtasksWidget init thread ID " << QThread::currentThreadId();

    threadPreparation = new QThread();
    taskTreePreparation = new TaskTreePreparation();
    taskTreePreparation->moveToThread(threadPreparation);
    threadPreparation->start();
    threadPreparation->setPriority(QThread::HighestPriority);
    connect(this, &AMMtasksWidget::signal_prepareListItems, taskTreePreparation, &TaskTreePreparation::slot_prepareListItems);
    connect(taskTreePreparation, &TaskTreePreparation::signal_listItemsReady, this, &AMMtasksWidget::slot_listItemsReady);

    waitAnimationWidget = new WaitAnimationWidget;
    QMovie *movie = new QMovie(":/resources/icons/762.gif");
    waitAnimationWidget->setParent(this);
    waitAnimationWidget->initialize(movie,this);
    waitAnimationWidget->moveToThread(threadPreparation);
}

AMMtasksWidget::~AMMtasksWidget()
{
    deleteAllModuls();
    delete ui;
}

void AMMtasksWidget::resizeEvent(QResizeEvent *event)
{
    QSize size = event->size();
    waitAnimationWidget->resize(size);
}

void AMMtasksWidget::on_treeWidget_currentItemChanged(QTreeWidgetItem *current, QTreeWidgetItem *previous)
{
    if(current == nullptr)
        return;

    int id = current->text(ColumnsTree::clmn_ID).toInt();

    Module* module = searchModuleByID(id);

    if(module)
    {
        QString type = "Code";
        QString code = "";

        if(module->getType() == ModuleType::TYPE_PM)
        {
            PM* PMmodul = static_cast<PM*>(module);
            type = "PM";
            code = PMmodul->pmCode();
            ui->btnAssignTaskToTrainee->setEnabled(false);
        }
        else
        {
            DM* DMmodul = static_cast<DM*>(module);
            type = "DM";
            code = DMmodul->dmCode();
            ui->btnAssignTaskToTrainee->setEnabled(true);
        }

        ui->label->setText(type + " Code");
        ui->editCode->setText(code);
    }
    else
        ui->btnAssignTaskToTrainee->setEnabled(false);
}

void AMMtasksWidget::slot_NeedUpdateUI()
{
    qDebug() << "AMMtasksWidget::slot_NeedUpdateUI thread ID " << QThread::currentThreadId();
    loadTasksAMM();
}

void AMMtasksWidget::slot_traineeSelected(QString login)
{
    qDebug() << "AMMtasksWidget::slot_traineeSelected thread ID " << QThread::currentThreadId();
    loginTraineeSelected = login;
}

void AMMtasksWidget::loadTasksAMM()
{
    //Обновление дерева
    treeWidget->clear();

    waitAnimationWidget->showWithPlay();

    QByteArray array = connectorToServer->getListTaskAmmArray();
    loadAMMtasksFromXML(array);

    //fillTree();
    signal_prepareListItems(listAllModules);    
}

void AMMtasksWidget::slot_listItemsReady(QList<QTreeWidgetItem *> listItems)
{
    //Обновление дерева
    treeWidget->clear();

    for(QTreeWidgetItem * item : listItems)
    {
        treeWidget->addTopLevelItem(item);
    }

    waitAnimationWidget->hideWithStop();
}

void AMMtasksWidget::domElementParser(QDomElement element, Module* moduleParent)
{
    QString name;

    QDomElement childElement = element.firstChildElement();
    if(childElement.isNull())
        return;

    Module* module = nullptr;

    do
    {
        name = childElement.nodeName();

       QDomNamedNodeMap nodeMap = childElement.attributes();

       if(name == "pm")
       {
           module = new PM();
           PM* PMmodul = static_cast<PM*>(module);

           PMmodul->initialize(nodeMap.namedItem("modelIdentCode").nodeValue(),
                               nodeMap.namedItem("pmIssuer").nodeValue(),
                               nodeMap.namedItem("pmNumber").nodeValue(),
                               nodeMap.namedItem("pmVolume").nodeValue());

           if(moduleParent)
           {
               PMmodul->setParentModule(moduleParent);

               PM* PMmodulParent = static_cast<PM*>(moduleParent);
               PMmodulParent->addChildModule(module);
           }
       }
       else if(name == "dm")
       {
           module = new DM();
           DM* DMmodul = static_cast<DM*>(module);

           DMmodul->initialize(nodeMap.namedItem("modelIdentCode").nodeValue(),
                               nodeMap.namedItem("systemDiffCode").nodeValue(),
                               nodeMap.namedItem("systemCode").nodeValue(),
                               nodeMap.namedItem("subSystemCode").nodeValue(),
                               nodeMap.namedItem("subSubSystemCode").nodeValue(),
                               nodeMap.namedItem("assyCode").nodeValue(),
                               nodeMap.namedItem("disassyCode").nodeValue(),
                               nodeMap.namedItem("disassyCodeVariant").nodeValue(),
                               nodeMap.namedItem("infoCode").nodeValue(),
                               nodeMap.namedItem("infoCodeVariant").nodeValue(),
                               nodeMap.namedItem("itemLocationCode").nodeValue());

           if(moduleParent)
           {
               DMmodul->setParentModule(moduleParent);

               PM* PMmodulParent = static_cast<PM*>(moduleParent);
               PMmodulParent->addChildModule(module);
           }
       }
       else if(name == "rus" || name == "eng")
       {
           if(moduleParent)
           {
               if(moduleParent->getType() == ModuleType::TYPE_PM)
               {//PM
                   PM* PMmodulParent = static_cast<PM*>(moduleParent);

                   if(name == "rus")
                        PMmodulParent->setLangStructRus(nodeMap.namedItem("title").nodeValue());
                   else
                        PMmodulParent->setLangStructEng(nodeMap.namedItem("title").nodeValue());
               }
               else
               {//DM
                   DM* DMmodulParent = static_cast<DM*>(moduleParent);

                   if(name == "rus")
                        DMmodulParent->setLangStructRus(nodeMap.namedItem("techName").nodeValue(),
                                                        nodeMap.namedItem("infoName").nodeValue(),
                                                        nodeMap.namedItem("pdf").nodeValue(),
                                                        nodeMap.namedItem("bookmark").nodeValue(),
                                                        nodeMap.namedItem("xml").nodeValue());
                   else
                       DMmodulParent->setLangStructEng(nodeMap.namedItem("techName").nodeValue(),
                                                       nodeMap.namedItem("infoName").nodeValue(),
                                                       nodeMap.namedItem("pdf").nodeValue(),
                                                       nodeMap.namedItem("bookmark").nodeValue(),
                                                       nodeMap.namedItem("xml").nodeValue());
               }
           }

       }

        domElementParser(childElement, module);

        if(moduleParent == nullptr)
            listAllModules.append(module);

    }while (! (childElement = childElement.nextSiblingElement()).isNull());
}

void AMMtasksWidget::loadAMMtasksFromXML(QByteArray array)
{
    deleteAllModuls();

    QDomDocument docTasksDOM;

    docTasksDOM.setContent(array);

    QDomElement manifestElement = docTasksDOM.firstChildElement("manifest");
    if(manifestElement.isNull())
        return;

    domElementParser(manifestElement, nullptr);
}

void AMMtasksWidget::deleteAllModuls()
{
    for(Module* module: listAllModules)
    {
        if(module->getType() == ModuleType::TYPE_PM)
            delete static_cast<PM*>(module);
        else
            delete static_cast<DM*>(module);
    }
    listAllModules.clear();
}

Module *AMMtasksWidget::searchModuleByID(int id)
{
    Module* ptrModule = nullptr;

    for(Module* module: listAllModules)
    {
        ptrModule = module->getModuleByID(id);
        if(ptrModule)
            return ptrModule;
    }

    return nullptr;
}

void AMMtasksWidget::preparationTreeWidget()
{
    treeWidget->setColumnCount(2);

    reSetHeadTreeWidget();

    treeWidget->setColumnWidth(ColumnsTree::clmn_ID, 80);
    treeWidget->setColumnWidth(ColumnsTree::clmn_PMorDM, 900);

    //treeWidget->setColumnHidden(ColumnsTree::clmn_ID, true);
}

void AMMtasksWidget::reSetHeadTreeWidget()
{
    QStringList listHeaders = {tr("PM/DM"), tr("ID")};
    treeWidget->setHeaderLabels(listHeaders);
}

void AMMtasksWidget::fillTree()
{
    //Обновление дерева
    treeWidget->clear();

    for(Module* module : listAllModules)
    {
        QTreeWidgetItem*  item = addModuleToTreeWidget(module);
        treeWidget->addTopLevelItem(item);
    }
}

QTreeWidgetItem* AMMtasksWidget::addModuleToTreeWidget(Module *module, QTreeWidgetItem* parentItem)
{
    QTreeWidgetItem* itemModule = nullptr;

    QString text;
    QString ID = QString::number(module->getID());

    if(parentItem)
    {
        itemModule = new QTreeWidgetItem();
        parentItem->addChild(itemModule);
    }
    else
    {
        //itemModule = new QTreeWidgetItem(treeWidget);
        itemModule = new QTreeWidgetItem();
    }

    if(module->getType() == ModuleType::TYPE_PM)
    {
        PM* PMmodul = static_cast<PM*>(module);
        text = PMmodul->getLangStructRus().title;

        for(Module* module : PMmodul->getListChildModules())
        {
            addModuleToTreeWidget(module, itemModule);
        }
    }
    else
    {
        DM* DMmodul = static_cast<DM*>(module);
        text = DMmodul->getLangStructRus().techName;

        //itemModule->setFlags(itemModule->flags() | Qt::ItemIsUserCheckable);
        //itemModule->setCheckState(0, Qt::Checked);
        itemModule->setIcon(0, QIcon(":/resources/icons/procedure.png"));
    }

    itemModule->setText(ColumnsTree::clmn_PMorDM, text);
    itemModule->setText(ColumnsTree::clmn_ID, ID);

    return itemModule;
}


void AMMtasksWidget::on_btnUpdateTasks_clicked()
{
    connectorToServer->sendQueryTasksXML("amm");
}

void AMMtasksWidget::on_btnAssignTaskToTrainee_clicked()
{
    QTreeWidgetItem *current = treeWidget->currentItem();

    if(current == nullptr)
        return;

    int id = current->text(ColumnsTree::clmn_ID).toInt();

    Module* module = searchModuleByID(id);

    if(module)
    {
        if(module->getType() == ModuleType::TYPE_DM)
        {
            QString dmCode = "";
            QString techName = "";
            DM* DMmodul = static_cast<DM*>(module);
            dmCode = DMmodul->dmCode();
            techName = DMmodul->getLangStructRus().techName;

            int trainee_id = connectorToServer->getIdTraineeByLogin(loginTraineeSelected);

            TaskAmmFim taskNew;
            taskNew.ammProcedure.title = techName;
            taskNew.ammProcedure.dmCode = dmCode;

            connectorToServer->sendQueryToDB(TypeQueryToDB::TYPE_QUERY_ASSIGN_TASK_AMM_TO_TRAINEE, trainee_id, &taskNew);
        }
    }
}