RRJServer/InstructorsAndTrainees/tasks/fimtaskswidget.cpp

#include <QDomDocument>
#include <QFile>
#include <QMessageBox>
#include <QTreeWidget>
#include <QThread>
#include <QResizeEvent>
#include "fimtaskswidget.h"
#include "ui_fimtaskswidget.h"
#include "tasksAmmFim.h"

FIMtasksWidget::FIMtasksWidget(ConnectorToServer* connectorToServer, TypeList type, QWidget *parent) :
    QWidget(parent),
    ui(new Ui::FIMtasksWidget),
    connectorToServer(connectorToServer),
    treeWidget(nullptr),
    type(type),
    userName(""),
    loginTraineeSelected(""),
    idTraineeSelected(0),
    threadAnimation(nullptr),
    waitAnimationWidget(nullptr),
    accessAssignTask(false)
{
    ui->setupUi(this);

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

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

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

    preparationTreeWidget();

    Q_EMIT signal_currentItemChanged();

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

FIMtasksWidget::~FIMtasksWidget()
{
    deleteAllTaskAmmFim();

    waitAnimationWidget->hideWithStop();

    threadAnimation->quit();
    threadAnimation->wait();

    delete threadAnimation;

    delete waitAnimationWidget;
    delete  treeWidget;

    delete ui;
}

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

    int width = treeWidget->width();

    treeWidget->setColumnWidth(ColumnsTree::clmn_ID, 50);

    int widthTitle;
    if(type == TypeList::listCommon)
        widthTitle = width - (0 + 10);
    else
        widthTitle = width - (50 + 10);

    treeWidget->setColumnWidth(ColumnsTree::clmn_Title, widthTitle);
}

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

    QString code = "";

    QTreeWidgetItem *treeItemParent = current->parent();
    if(treeItemParent == nullptr)
    {//Выбрана задача
        int id = current->text(ColumnsTree::clmn_ID).toInt();

        TaskAmmFim* task = getTaskByID(id);

        code = task->title;

        accessAssignTask = true;
    }
    else
    {
        accessAssignTask = false;
    }

    Q_EMIT signal_currentItemChanged();
}

void FIMtasksWidget::loadFIMtasksFromXML(QByteArray array)
{
    deleteAllTaskAmmFim();

    QDomDocument docTasksDOM;

    docTasksDOM.setContent(array);

    QDomElement RRJTasksElement = docTasksDOM.firstChildElement("RRJTasks");
    if(RRJTasksElement.isNull())
        return;

    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 FIMtasksWidget::fillTree()
{
    //Обновление дерева
    treeWidget->clear();

    for(int i = 0; i < listTaskAmmFim.count(); i++)
    {/*Задачи*/
        TaskAmmFim* task = listTaskAmmFim.at(i);

        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);
        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);
            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);
            }
        }
    }
}

void FIMtasksWidget::prepareListTasksForTrainee(QList<TaskAmmFim> listTask)
{
    deleteAllTaskAmmFim();

    for(TaskAmmFim task : listTask)
    {
        TaskAmmFim* newTask = new TaskAmmFim();
        *newTask = task;

        listTaskAmmFim.append(newTask);
    }
}

void FIMtasksWidget::preparationTreeWidget()
{
    treeWidget->setColumnCount(clmn_count);

    reSetHeadTreeWidget();

    if(type == TypeList::listCommon)
        treeWidget->setColumnHidden(ColumnsTree::clmn_ID, true);
}

void FIMtasksWidget::reSetHeadTreeWidget()
{
    QStringList listHeaders;

    if(type == TypeList::listForTrainee)
        listHeaders = QStringList{tr("Task FIM"), tr("ID")};
    else
        listHeaders = QStringList{tr("Title"), tr("ID")};

    treeWidget->setHeaderLabels(listHeaders);
}

void FIMtasksWidget::slot_NeedUpdateUI()
{
    qDebug() << "FIMtasksWidget::slot_NeedUpdateUI thread ID " << QThread::currentThreadId();
    loadTasksFIM();
}

void FIMtasksWidget::slot_traineeSelected(QString login)
{
    qDebug() << "FIMtasksWidget::slot_traineeSelected thread ID " << QThread::currentThreadId();
    loginTraineeSelected = login;
    idTraineeSelected = connectorToServer->getIdTraineeByLogin(loginTraineeSelected);

    if(type == TypeList::listForTrainee)
    {
        waitAnimationWidget->showWithPlay();
        connectorToServer->sendQueryToDB(TypeQueryToDB::TYPE_QUERY_GET_TASKS_FIM_FOR_TRAINEE, idTraineeSelected);
    }
}

void FIMtasksWidget::slot_UpdateTasksFIMforTrainee(int trainee_id)
{
    if(type == TypeList::listForTrainee)
    {
        if(idTraineeSelected == trainee_id)
        {
            QList<TaskAmmFim> listTask = connectorToServer->getListTasksFIMforTrainee(trainee_id);
            prepareListTasksForTrainee(listTask);
            fillTree();
            waitAnimationWidget->hideWithStop();
        }
    }
}

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

    waitAnimationWidget->showWithPlay();

    QByteArray array = connectorToServer->getListTaskFimArray();
    loadFIMtasksFromXML(array);

    //собственно обновление дерева
    fillTree();

    waitAnimationWidget->hideWithStop();
}

TaskAmmFim* FIMtasksWidget::getTaskByID(int id)
{
    for(int i = 0; i < listTaskAmmFim.count(); i++)
    {/*Задачи*/
        TaskAmmFim* task = listTaskAmmFim.at(i);
        if(task->id == id)
            return task;
    }

    return nullptr;
}

void FIMtasksWidget::deleteAllTaskAmmFim()
{
    for(TaskAmmFim* task: listTaskAmmFim)
        delete task;

    listTaskAmmFim.clear();
}

void FIMtasksWidget::updateTaskItem(QTreeWidgetItem *itemTask)
{
    for (int i = 0; i < itemTask->childCount(); i++)
    {
        QTreeWidgetItem* itemMalfunction = itemTask->child(i);
        itemMalfunction->setCheckState(0, Qt::Checked);
        itemMalfunction->setExpanded(false);
    }
    itemTask->setExpanded(false);
}

void FIMtasksWidget::on_btnUpdateTasks_clicked()
{
    connectorToServer->sendQueryTasksXML("fim");
}

void FIMtasksWidget::slot_AssignTaskFIMtoTrainee()
{
    QTreeWidgetItem *current = treeWidget->currentItem();

    if(current == nullptr)
        return;

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

    TaskAmmFim* task = getTaskByID(id);

    if(task)
    {
        int trainee_id = connectorToServer->getIdTraineeByLogin(loginTraineeSelected);

        TaskAmmFim taskNew;
        taskNew.title = task->title;

        //Назначенные неисправности
        for (int i = 0; i < current->childCount(); i++)
        {
            QTreeWidgetItem* itemMalfunction = current->child(i);

            if(itemMalfunction->checkState(0) == Qt::Checked)
            {
                Malfunction malfunction = task->malfunctionList.at(i);
                taskNew.malfunctionList.append(malfunction);
            }
        }

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

        updateTaskItem(current);
    }
}