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, TypeList type, QWidget *parent) :
    QWidget(parent),
    ui(new Ui::AMMtasksWidget),
    connectorToServer(connectorToServer),
    treeWidget(nullptr),
    type(type),
    loginTraineeSelected(""),
    idTraineeSelected(0),
    threadPreparation(nullptr),
    threadAnimation(nullptr),
    taskTreePreparation(nullptr),
    waitAnimationWidget(nullptr),
    accessAssignTask(false)
{
    ui->setupUi(this);

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

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

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

    preparationTreeWidget();

    Q_EMIT signal_currentItemChanged();

    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(this, &AMMtasksWidget::signal_prepareListItemsForTrainee, taskTreePreparation, &TaskTreePreparation::slot_prepareListItemsForTrainee);
    connect(taskTreePreparation, &TaskTreePreparation::signal_listItemsReady, this, &AMMtasksWidget::slot_listItemsReady);

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

    ui->btnDelete->setEnabled(false);
    if(type == TypeList::listCommon)
        ui->btnDelete->setVisible(false);
}

AMMtasksWidget::~AMMtasksWidget()
{
    waitAnimationWidget->hideWithStop();
    taskTreePreparation->stopParser();

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

    threadPreparation->quit();
    threadPreparation->wait();

    delete threadAnimation;
    delete threadPreparation;

    delete  taskTreePreparation;
    delete waitAnimationWidget;
    delete  treeWidget;
    delete ui;
}

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

    int width = treeWidget->width();

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

    int widthPMorDM;
    if(type == TypeList::listCommon)
        widthPMorDM = width - (250 + 10);
    else
        widthPMorDM = width - (300 + 10);

    treeWidget->setColumnWidth(ColumnsTree::clmn_PMorDM, widthPMorDM);
}

void AMMtasksWidget::changeEvent(QEvent *event)
{
    // В случае получения события изменения языка приложения
    if (event->type() == QEvent::LanguageChange)
    {// переведём окно заново
        ui->retranslateUi(this);

        reSetHeadTreeWidget();

        //slot_NeedUpdateUI();
    }
}

void AMMtasksWidget::on_treeWidget_currentItemChanged(QTreeWidgetItem *current, QTreeWidgetItem *previous)
{
    if(current == nullptr)
    {
        ui->btnDelete->setEnabled(false);
        return;
    }
    else
    {
        ui->btnDelete->setEnabled(true);
    }

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

            accessAssignTask = false;
        }
        else
        {
            DM* DMmodul = static_cast<DM*>(module);
            type = "DM";
            code = DMmodul->dmCode();

            accessAssignTask = true;
        }
    }
    else
    {
        accessAssignTask = false;
    }
    Q_EMIT signal_currentItemChanged();
}

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;
    idTraineeSelected = connectorToServer->getIdTraineeByLogin(loginTraineeSelected);

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

void AMMtasksWidget::slot_UpdateTasksAMMforTrainee(int trainee_id)
{
    if(type == TypeList::listForTrainee)
    {
        if(idTraineeSelected == trainee_id)
        {
            //waitAnimationWidget->showWithPlay();
            QList<TaskAmmFim> listTask = connectorToServer->getListTasksAMMforTrainee(trainee_id);
            signal_prepareListItemsForTrainee(listTask, &listAllModules);
        }
    }
}

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

    waitAnimationWidget->showWithPlay();

    QByteArray array = connectorToServer->getListTaskAmmArray();

    signal_prepareListItems(array, &listAllModules);
}

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

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

    QTreeWidgetItem * item = treeWidget->topLevelItem(0);
    if(item != nullptr)
        treeWidget->setCurrentItem(item);

    waitAnimationWidget->hideWithStop();
}

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(clmn_count);

    reSetHeadTreeWidget();

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

void AMMtasksWidget::reSetHeadTreeWidget()
{
    QStringList listHeaders;

    if(type == TypeList::listForTrainee)
        listHeaders = QStringList{tr("Task AMM"), tr("DM code"), tr("ID")};
    else
        listHeaders = QStringList{tr("PM/DM"), tr("Code"), tr("ID")};


    treeWidget->setHeaderLabels(listHeaders);
}

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

void AMMtasksWidget::slot_AssignTaskAMMtoTrainee()
{
    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);
        }
    }
}

void AMMtasksWidget::on_btnDelete_clicked()
{
    QTreeWidgetItem *treeItemCurrent = treeWidget->currentItem();

    if(treeItemCurrent != nullptr)
    {
        QTreeWidgetItem *treeItemParent = treeItemCurrent->parent();
        if(treeItemParent == nullptr)
        {//Выбрана задача

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

            if(QMessageBox::warning(this, tr("Attention!"), tr("The deletion will be irrevocable.\nDelete it anyway?"), QMessageBox::Ok, QMessageBox::Cancel) == QMessageBox::Ok)
            {
                connectorToServer->sendQueryToDB(TypeQueryToDB::TYPE_QUERY_DEL_TASK_AMM_TO_TRAINEE, id);
            }
        }
    }
}