Merge branch 'work17' into DEV

DataBaseLMS/CMakeLists.txt

@@ -5,6 +5,11 @@ common_info_for_project(DataBaseLMS)
 add_library(DataBaseLMS SHARED
   DataBaseLMS_global.h
   databaselms.cpp
+  databaselms_tasks.cpp
+  databaselms_groups.cpp
+  databaselms_users.cpp
+  databaselms_instructors.cpp
+  databaselms_trainees.cpp
   databaselms.h
   interfacedatabaselms.cpp
   interfacedatabaselms.h
@@ -28,6 +33,7 @@ add_library(DataBaseLMS SHARED
   timingoftrainee.cpp
   timingoftrainee.h
   contactModel.h
+  resources.qrc
 )
 
 target_link_libraries(DataBaseLMS PRIVATE Qt5::Widgets)

DataBaseLMS/databaselms.h

@@ -3,6 +3,7 @@
 
 #include <QSqlDatabase>
 #include <QMutex>
+#include <QWidget>
 
 #include "instructor.h"
 #include "trainee.h"
@@ -25,47 +26,61 @@ public:
 class DataBaseLMS
 {
 public:
-    DataBaseLMS();
+    DataBaseLMS(QWidget *ownerWidget);
     ~DataBaseLMS();
 
+public:
+    static const QString TypeUserDBInstructor;
+    static const QString TypeUserDBTrainee;
+
 protected:
     //Подключение
     bool createConnection();
     void deleteConnection();
     bool isConnected();
 
-    //Транзакции
+    //Юзер
-    bool transactionBegin();
+    int selectUserID(QString type, QString login, QString password = QStringLiteral(""));
-    bool transactionEnd();
+    QString selectUserNameByLogin(QString type, QString login);
-
+    bool selectUserLoggedIn(QString type, int id_user);
-    //Списки
+    bool selectUserArchived(QString type, int id_user);
-    QList<Instructor> selectAllInstructors();
+    int updateUserLoggedIn(QString type, int id_user, bool loggedIn);
-    QList<Trainee> selectAllTrainees();
+    bool updateAllUsersLoggedIn(QString type, bool loggedIn);
-    QList<Group> selectAllGroups();
+    int updateUserArchived(QString type, int id_user, bool archived);
 
     //Инструктор
+    QList<Instructor> selectAllInstructors();
     Instructor selectInstructor(int id_instructor);
-    int selectInstructorID(QString login, QString password = QStringLiteral(""));
-    QString selectInstructorNameByLogin(QString login);
     bool selectInstructorIsAdmin(int id_instructor);
-    bool selectInstructorLoggedIn(int id_instructor);
-    bool selectInstructorArchived(int id_instructor);
-    int updateInstructorLoggedIn(int id_instructor, bool loggedIn);
-    bool updateAllInstructorsLoggedIn(bool loggedIn);
-    int updateInstructorArchived(int id_instructor, bool archived);
-
     int insertInstructor();
     int insertInstructor(Instructor instructor);
     int deleteInstructor(int id_instructor);
     int updateInstructor(Instructor instructor);
 
     //Группа
+    QList<Group> selectAllGroups();
     Group selectGroup(int id_group);
     int insertGroup();
     int insertGroup(Group group);
     int deleteGroup(int id_group);
     int updateGroup(Group group);
 
+    //Обучаемый
+    QList<Trainee> selectAllTrainees();
+    Trainee selectTrainee(int id_trainee);
+    QList<Trainee> selectAllTraineesInGroup(int id_group);
+    QString selectTraineeNameOnComputer(QString computer_name);
+    Trainee selectTraineeOnComputer(QString computer_name);
+    int insertTrainee(int id_group);
+    int insertTrainee(Trainee trainee);
+    int deleteTrainee(int id_trainee);
+    int updateTrainee(Trainee trainee);
+
+    //Тайминг
+    int insertTimingTrainee(int id_trainee);
+    int updateTimingTrainee(int id_trainee, TimingOfTrainee timing);
+    TimingOfTrainee selectTimingTrainee(int id_trainee);
+
     //Задача AMM
     int insertTaskAMM(TaskAmmFim task, int id_trainee);
     int updateTaskAMM(TaskAmmFim task);
@@ -80,32 +95,9 @@ protected:
     int deleteTaskFIM(int id_task);
     QList<TaskAmmFim> selectTasksFIMofTrainee(int id_trainee);
     TaskAmmFim selectTaskFIMbyID(int id_task);
-
+    //int deleteReportFIMforTask(int task_id);
-    int deleteReportFIM(int task_id);
+    //int insertReportFIMforTask(TaskAmmFim task);
-    int insertReportFIM(TaskAmmFim task);
+    int updateReportFIMforTask(TaskAmmFim task);
-
-    //Обучаемый
-    Trainee selectTrainee(int id_trainee);
-    QList<Trainee> selectAllTraineesInGroup(int id_group);
-    int selectTraineeID(QString login, QString password = QStringLiteral(""));
-    QString selectTraineeNameByLogin(QString login);
-    QString selectTraineeNameOnComputer(QString computer_name);
-    Trainee selectTraineeOnComputer(QString computer_name);
-    bool selectTraineeArchived(int id_trainee);
-    bool selectTraineeLoggedIn(int id_trainee);
-    int updateTraineeLoggedIn(int id_trainee, bool loggedIn);
-    bool updateAllTraineesLoggedIn(bool loggedIn);
-    int updateTraineeArchived(int id_trainee, bool archived);
-
-    int insertTrainee(int id_group);
-    int insertTrainee(Trainee trainee);
-    int deleteTrainee(int id_trainee);
-    int updateTrainee(Trainee trainee);
-
-    //Тайминг
-    int insertTimingTrainee(int id_trainee);
-    int updateTimingTrainee(int id_trainee, TimingOfTrainee timing);
-    TimingOfTrainee selectTimingTrainee(int id_trainee);
 
 private:
     DataBaseSettings getDataBaseSettings();
@@ -120,8 +112,8 @@ protected:
     DataBaseSettings dbSettings;
 
 private:
-    bool transactionBegined;
+    bool transactionBegined;    
-    QMutex mtxAccess;
+    QWidget* ownerWidget;
 };
 
 #endif // DATABASELMS_H

DataBaseLMS/databaselms_groups.cpp

@@ -0,0 +1,95 @@
+#include "databaselms.h"
+
+#include <QtSql>
+#include <QSqlDatabase>
+#include <QSqlDriver>
+#include <QMessageBox>
+
+
+QList<Group> DataBaseLMS::selectAllGroups()
+{
+    QList<Group> listGroups;
+
+    QString queryStr = QString("SELECT group_id, name "
+                                                 "FROM public.groups "
+                                                 "ORDER BY group_id ASC");
+
+    QSqlQuery query = QSqlQuery(*db);
+
+    if(queryExec(queryStr, &query))
+    {
+        while (query.next())
+        {//Группа
+            Group group;
+            group.setID(query.value(0).toInt());
+            group.setName(query.value(1).toString());
+
+            listGroups.append(group);
+        }
+    }
+
+    return listGroups;
+}
+
+Group DataBaseLMS::selectGroup(int id_group)
+{
+    Group group;
+
+    QString queryStr = QString("SELECT group_id, name "
+                                                 "FROM public.groups "
+                                                 "WHERE groups.group_id = %1 ").arg(
+                                                        id_group);
+
+    QSqlQuery query = QSqlQuery(*db);
+
+    if(queryExec(queryStr, &query))
+    {
+        if (query.first())
+        {//Инструктор
+            group.setID(query.value(0).toInt());
+            group.setName(query.value(1).toString());
+        }
+    }
+
+    return group;
+}
+
+int DataBaseLMS::insertGroup()
+{
+    QString queryStr = QString("INSERT INTO public.groups "
+                                                 "DEFAULT VALUES "
+                                                 "RETURNING group_id");
+
+    return queryExecInt(queryStr);
+}
+
+int DataBaseLMS::insertGroup(Group group)
+{
+    QString queryStr = QString("INSERT INTO public.groups (name) "
+                                                 "VALUES ('%1') "
+                                                 "RETURNING groups.group_id").arg(
+                                                        group.getName());
+
+    return queryExecInt(queryStr);
+}
+
+int DataBaseLMS::deleteGroup(int id_group)
+{
+    QString queryStr = QString("DELETE FROM public.groups "
+                                                 "WHERE group_id = %1 "
+                                                 "RETURNING groups.group_id").arg(
+                                                        QString::number(id_group));
+
+    return queryExecInt(queryStr);
+}
+
+int DataBaseLMS::updateGroup(Group group)
+{
+    QString queryStr = QString("UPDATE public.groups SET name = '%1' "
+                                                 "WHERE group_id = %2 "
+                                                 "RETURNING groups.group_id").arg(
+                                                        group.getName(),
+                                                        QString::number(group.getID()) );
+
+    return queryExecInt(queryStr);
+}

DataBaseLMS/databaselms_instructors.cpp

@@ -0,0 +1,134 @@
+#include "databaselms.h"
+
+#include <QtSql>
+#include <QSqlDatabase>
+#include <QSqlDriver>
+#include <QMessageBox>
+
+
+QList<Instructor> DataBaseLMS::selectAllInstructors()
+{
+    QList<Instructor> listInstructors;
+
+    QString queryStr = QString("SELECT user_id, name, login, password, is_admin, archived, logged_in "
+                                                 "FROM public.users "
+                                                 "WHERE users.type = '%1' "
+                                                 "ORDER BY user_id ASC").arg(
+                                                    TypeUserDBInstructor);
+
+    QSqlQuery query = QSqlQuery(*db);
+
+    if(queryExec(queryStr, &query))
+    {
+        while (query.next())
+        {//Инструктор
+            Instructor instructor;
+            instructor.setID(query.value(0).toInt());
+            instructor.setName(query.value(1).toString());
+            instructor.setLogin(query.value(2).toString());
+            instructor.setPassword(query.value(3).toString());
+            instructor.setIsAdmin(query.value(4).toBool());
+            instructor.setArchived(query.value(5).toBool());
+            instructor.setLoggedIn(query.value(6).toBool());
+
+            listInstructors.append(instructor);
+        }
+    }
+
+    return listInstructors;
+}
+
+Instructor DataBaseLMS::selectInstructor(int id_instructor)
+{
+    Instructor instructor;
+
+    QString queryStr = QString("SELECT user_id, name, login, password, is_admin, archived, logged_in "
+                                                 "FROM public.users "
+                                                 "WHERE users.user_id = %1 AND users.type = '%2' ").arg(
+                                                     QString::number(id_instructor),
+                                                     TypeUserDBInstructor);
+
+    QSqlQuery query = QSqlQuery(*db);
+
+    if(queryExec(queryStr, &query))
+    {
+        if (query.first())
+        {//Инструктор
+            instructor.setID(query.value(0).toInt());
+            instructor.setName(query.value(1).toString());
+            instructor.setLogin(query.value(2).toString());
+            instructor.setPassword(query.value(3).toString());
+            instructor.setIsAdmin(query.value(4).toBool());
+            instructor.setArchived(query.value(5).toBool());
+            instructor.setLoggedIn(query.value(6).toBool());
+        }
+    }
+
+    return instructor;
+}
+
+bool DataBaseLMS::selectInstructorIsAdmin(int id_instructor)
+{
+    QString queryStr = QString("SELECT users.is_admin "
+                                                  "FROM public.users "
+                                                  "WHERE user_id = %1 AND users.type = '%2' ").arg(
+                                                         QString::number(id_instructor),
+                                                         TypeUserDBInstructor );
+
+    return queryExecBool(queryStr);
+}
+
+int DataBaseLMS::insertInstructor()
+{
+    QString queryStr = QString("INSERT INTO public.users (type, name, login, password, is_admin, archived, logged_in)"
+                                                 "VALUES ('%1', DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT)"
+                                                 "RETURNING user_id").arg(
+                                                        TypeUserDBInstructor);
+
+    return queryExecInt(queryStr);
+}
+
+int DataBaseLMS::insertInstructor(Instructor instructor)
+{
+    QString queryStr = QString("INSERT INTO public.users (type, name, login, password, is_admin, archived, logged_in) "
+                                                 "VALUES ('%1', '%2', '%3', '%4', %5, %6, %7) "
+                                                 "RETURNING user_id").arg(
+                                                        TypeUserDBInstructor,
+                                                        instructor.getName(),
+                                                        instructor.getLogin(),
+                                                        instructor.getPassword(),
+                                                        instructor.getIsAdmin() ? "true" : "false",
+                                                        instructor.getArchived() ? "true" : "false",
+                                                        instructor.getLoggedIn() ? "true" : "false");
+
+    return queryExecInt(queryStr);
+}
+
+int DataBaseLMS::deleteInstructor(int id_instructor)
+{
+    QString queryStr = QString("DELETE FROM public.users "
+                                                 "WHERE user_id = %1 AND users.type = '%2' "
+                                                 "RETURNING users.user_id").arg(
+                                                        QString::number(id_instructor),
+                                                        TypeUserDBInstructor);
+
+    return queryExecInt(queryStr);
+}
+
+int DataBaseLMS::updateInstructor(Instructor instructor)
+{
+    QString queryStr = QString("UPDATE public.users "
+                                                 "SET name = '%1', login = '%2', password = '%3', is_admin = %4, archived = %5, logged_in = %6 "
+                                                 "WHERE user_id = %7 AND users.type = '%8' "
+                                                 "RETURNING users.user_id").arg(
+                                                        instructor.getName(),
+                                                        instructor.getLogin(),
+                                                        instructor.getPassword(),
+                                                        instructor.getIsAdmin() ? "true" : "false",
+                                                        instructor.getArchived() ? "true" : "false",
+                                                        instructor.getLoggedIn() ? "true" : "false",
+                                                        QString::number(instructor.getID()),
+                                                        TypeUserDBInstructor);
+
+    return queryExecInt(queryStr);
+}

DataBaseLMS/databaselms_tasks.cpp

@@ -0,0 +1,847 @@
+#include "databaselms.h"
+
+#include <QtSql>
+#include <QSqlDatabase>
+#include <QSqlDriver>
+#include <QMessageBox>
+
+int DataBaseLMS::insertTaskAMM(TaskAmmFim task, int id_trainee)
+{
+    task.ammProcedure.title = task.ammProcedure.title.replace("'", "''"); //Задваиваем одинарные кавычки
+
+    QString queryStr = QString("INSERT INTO public.tasks_amm (title, dm_code, fk_trainee_id) "
+                                                 "VALUES ('%1', '%2', %3) "
+                                                 "RETURNING tasks_amm.task_id").arg(
+                                                        task.ammProcedure.title,
+                                                        task.ammProcedure.dmCode,
+                                                        QString::number(id_trainee));
+
+    return queryExecInt(queryStr);
+}
+
+int DataBaseLMS::updateTaskAMM(TaskAmmFim task)
+{
+    task.ammProcedure.title = task.ammProcedure.title.replace("'", "''"); //Задваиваем одинарные кавычки
+
+    QString queryStr = QString("UPDATE public.tasks_amm SET title = '%1', dm_code = '%2', status = '%3' "
+                                                 "WHERE task_id = %4 "
+                                                 "RETURNING tasks_amm.task_id").arg(
+                                                        task.ammProcedure.title,
+                                                        task.ammProcedure.dmCode,
+                                                        task.status,
+                                                        QString::number(task.getID()) );
+
+    return queryExecInt(queryStr);
+}
+
+int DataBaseLMS::updateStatusTaskAMM(int task_id, QString status)
+{
+    QString queryStr;
+    bool resBool = false;
+    int id_trainee = 0;
+
+    resBool = db->transaction();
+
+    queryStr = QString("SELECT users.user_id "
+                                                 "FROM public.users JOIN public.tasks_amm ON users.user_id = tasks_amm.fk_trainee_id "
+                                                 "WHERE tasks_amm.task_id = %1 "
+                                                 "ORDER BY users.user_id ASC").arg(
+                                                        QString::number(task_id));
+
+    QSqlQuery query = QSqlQuery(*db);
+
+    if(queryExec(queryStr, &query))
+    {
+        if (query.first())
+        {//Обучаемый
+            id_trainee = query.value(0).toInt();
+        }
+    }
+    if(!id_trainee)
+    {
+        resBool = db->rollback();
+        return 0;
+    }
+
+
+    queryStr = QString("UPDATE public.tasks_amm SET status = '%1' "
+                                                 "WHERE task_id = %2 "
+                                                 "RETURNING tasks_amm.task_id").arg(
+                                                        status,
+                                                        QString::number(task_id) );
+
+
+    if(!queryExecInt(queryStr))
+    {
+        resBool = db->rollback();
+        return 0;
+    }
+
+    resBool = db->commit();
+    return id_trainee;
+}
+
+int DataBaseLMS::deleteTaskAMM(int id_task)
+{
+    QString queryStr;
+    bool resBool = false;
+    int id_trainee = 0;
+
+    resBool = db->transaction();
+
+    queryStr = QString("SELECT users.user_id "
+                                                 "FROM public.users JOIN public.tasks_amm ON users.user_id = tasks_amm.fk_trainee_id "
+                                                 "WHERE tasks_amm.task_id = %1 "
+                                                 "ORDER BY users.user_id ASC").arg(
+                                                        QString::number(id_task));
+
+    QSqlQuery query = QSqlQuery(*db);
+
+    if(queryExec(queryStr, &query))
+    {
+        if (query.first())
+        {//Обучаемый
+            id_trainee = query.value(0).toInt();
+        }
+    }
+    if(!id_trainee)
+    {
+        resBool = db->rollback();
+        return 0;
+    }
+
+    queryStr = QString("DELETE FROM public.tasks_amm "
+                                                 "WHERE task_id = %1 "
+                                                 "RETURNING tasks_amm.task_id").arg(
+                                                        QString::number(id_task));
+
+    if(!queryExecInt(queryStr))
+    {
+        resBool = db->rollback();
+        return 0;
+    }
+
+    resBool = db->commit();
+    return id_trainee;
+}
+
+QList<TaskAmmFim> DataBaseLMS::selectTasksAMMofTrainee(int id_trainee)
+{
+    QList<TaskAmmFim> listTasks;
+
+    QString queryStr = QString("SELECT tasks_amm.task_id, tasks_amm.title, tasks_amm.dm_code, tasks_amm.status, "
+                                                 "users.user_id "
+                                                 "FROM public.tasks_amm JOIN public.users ON users.user_id = tasks_amm.fk_trainee_id "
+                                                 "WHERE tasks_amm.fk_trainee_id = %1 "
+                                                 "ORDER BY tasks_amm.task_id ASC").arg(
+                                                        id_trainee);
+
+    QSqlQuery query = QSqlQuery(*db);
+
+    if(queryExec(queryStr, &query))
+    {
+        while (query.next())
+        {//Задача
+            TaskAmmFim task;
+
+            task.setID(query.value(0).toInt());
+            task.ammProcedure.title = query.value(1).toString();
+            task.ammProcedure.dmCode = query.value(2).toString();
+            task.status = query.value(3).toString();
+
+            listTasks.append(task);
+        }
+    }
+
+    return listTasks;
+}
+
+TaskAmmFim DataBaseLMS::selectTaskAMMbyID(int id_task)
+{
+    TaskAmmFim task;
+
+    QString queryStr = QString("SELECT tasks_amm.task_id, tasks_amm.title, tasks_amm.dm_code, tasks_amm.status "
+                                                 "FROM public.tasks_amm "
+                                                 "WHERE tasks_amm.task_id = %1 "
+                                                 "ORDER BY tasks_amm.task_id ASC").arg(
+                                                        id_task);
+
+    QSqlQuery query = QSqlQuery(*db);
+
+    if(queryExec(queryStr, &query))
+    {
+        if (query.first())
+        {//Задача
+            task.setID(query.value(0).toInt());
+            task.ammProcedure.title = query.value(1).toString();
+            task.ammProcedure.dmCode = query.value(2).toString();
+            task.status = query.value(3).toString();
+        }
+    }
+
+    return task;
+}
+
+
+int DataBaseLMS::insertTaskFIM(TaskAmmFim task, int id_trainee)
+{
+    QString queryStr;
+    bool resBool = false;
+
+    resBool = db->transaction();
+
+    task.title = task.title.replace("'", "''"); //Задваиваем одинарные кавычки
+
+    queryStr = QString("INSERT INTO public.tasks_fim (title, fk_trainee_id) "
+                                                 "VALUES ('%1', %2) "
+                                                 "RETURNING tasks_fim.task_id").arg(
+                                                        task.title,
+                                                        QString::number(id_trainee));
+
+    int task_id = queryExecInt(queryStr);
+    if(!task_id)
+    {
+        resBool = db->rollback();
+        return 0;
+    }
+
+    for(Malfunction malfanction : task.malfunctionList)
+    {
+        malfanction.description = malfanction.description.replace("'", "''"); //Задваиваем одинарные кавычки
+
+        queryStr = QString("INSERT INTO public.malfunctions (num, dm_code, description, fk_task_fim_id) "
+                                                     "VALUES ('%1', '%2', '%3', %4) "
+                                                     "RETURNING malfunctions.malfunction_id").arg(
+                                                            malfanction.num,
+                                                            malfanction.dmCode,
+                                                            malfanction.description,
+                                                            QString::number(task_id));
+
+        int malfunction_id = queryExecInt(queryStr);
+        if(!malfunction_id)
+        {
+            resBool = db->rollback();
+            return 0;
+        }
+
+        //Sign
+        for(MalfunctionSign sign : malfanction.malfunctionSigns)
+        {
+            sign.description = sign.description.replace("'", "''"); //Задваиваем одинарные кавычки
+
+            queryStr = QString("INSERT INTO public.malf_signs (type, description, fk_malfunction_id) "
+                                                         "VALUES ('%1', '%2', %3) "
+                                                         "RETURNING malf_signs.sign_id").arg(
+                                                                QString::number(sign.type),
+                                                                sign.description,
+                                                                QString::number(malfunction_id));
+
+            if(!queryExecInt(queryStr))
+            {
+                resBool = db->rollback();
+                return 0;
+            }
+        }
+    }
+
+    resBool = db->commit();
+    return task_id;
+}
+
+int DataBaseLMS::updateTaskFIM(TaskAmmFim task)
+{
+    task.title = task.title.replace("'", "''"); //Задваиваем одинарные кавычки
+
+    QString queryStr = QString("UPDATE public.tasks_fim SET title = '%1', status = '%2' "
+                                                 "WHERE task_id = %3 "
+                                                 "RETURNING tasks_fim.task_id").arg(
+                                                        task.title,
+                                                        task.status,
+                                                        QString::number(task.getID()) );
+
+    return queryExecInt(queryStr);
+}
+
+int DataBaseLMS::updateStatusTaskFIM(int task_id, QString status)
+{
+    QString queryStr;
+    bool resBool = false;
+    int id_trainee = 0;
+
+    resBool = db->transaction();
+
+    queryStr = QString("SELECT users.user_id "
+                                                 "FROM public.users JOIN public.tasks_fim ON users.user_id = tasks_fim.fk_trainee_id "
+                                                 "WHERE tasks_fim.task_id = %1 "
+                                                 "ORDER BY users.user_id ASC").arg(
+                                                        QString::number(task_id));
+
+    QSqlQuery query = QSqlQuery(*db);
+
+    if(queryExec(queryStr, &query))
+    {
+        if (query.first())
+        {//Обучаемый
+            id_trainee = query.value(0).toInt();
+        }
+    }
+    if(!id_trainee)
+    {
+        resBool = db->rollback();
+        return 0;
+    }
+
+    queryStr = QString("UPDATE public.tasks_fim SET status = '%1' "
+                                                 "WHERE task_id = %2 "
+                                                 "RETURNING tasks_fim.task_id").arg(
+                                                        status,
+                                                        QString::number(task_id) );
+
+    QSqlQuery query1 = QSqlQuery(*db);
+    if(!queryExec(queryStr, &query1))
+    {
+        resBool = db->rollback();
+        return 0;
+    }
+
+    resBool = db->commit();
+    return id_trainee;
+}
+
+int DataBaseLMS::deleteTaskFIM(int id_task)
+{
+    QString queryStr;
+    bool resBool = false;
+    int id_trainee = 0;
+
+    resBool = db->transaction();
+
+    queryStr = QString("SELECT users.user_id "
+                                                 "FROM public.users JOIN public.tasks_fim ON users.user_id = tasks_fim.fk_trainee_id "
+                                                 "WHERE tasks_fim.task_id = %1 "
+                                                 "ORDER BY users.user_id ASC").arg(
+                                                        QString::number(id_task));
+
+    QSqlQuery queryUserSEL = QSqlQuery(*db);
+
+    if(queryExec(queryStr, &queryUserSEL))
+    {
+        if (queryUserSEL.first())
+        {//Обучаемый
+            id_trainee = queryUserSEL.value(0).toInt();
+        }
+    }
+    if(!id_trainee)
+    {
+        resBool = db->rollback();
+        return 0;
+    }
+
+    //Выгребаем все malfunction для этой задачи
+    queryStr = QString("SELECT malfunctions.malfunction_id "
+                                                 "FROM public.malfunctions JOIN public.tasks_fim ON tasks_fim.task_id = malfunctions.fk_task_fim_id "
+                                                 "WHERE malfunctions.fk_task_fim_id = %1 "
+                                                 "ORDER BY malfunctions.malfunction_id ASC").arg(
+                                                        id_task);
+    QSqlQuery queryMalfSEL = QSqlQuery(*db);
+
+    if(queryExec(queryStr, &queryMalfSEL))
+    {
+        while (queryMalfSEL.next())
+        {//Неисправность
+            int malfunction_id = 0;
+
+            malfunction_id = queryMalfSEL.value(0).toString().toInt();
+
+            if(malfunction_id)
+            {
+                queryStr = QString("DELETE FROM public.malf_signs "
+                                                             "WHERE fk_malfunction_id = %1 ").arg(
+                                                                    malfunction_id);
+
+                QSqlQuery querySignDEL = QSqlQuery(*db);
+                if(!queryExec(queryStr, &querySignDEL))
+                {
+                    resBool = db->rollback();
+                    return 0;
+                }
+            }
+        };
+    }
+    else
+    {
+        resBool = db->rollback();
+        return 0;
+    }
+
+
+    queryStr = QString("DELETE FROM public.malfunctions "
+                                                 "WHERE fk_task_fim_id = %1 ").arg(
+                                                        QString::number(id_task));
+
+    QSqlQuery queryMulfDEL = QSqlQuery(*db);
+    if(!queryExec(queryStr, &queryMulfDEL))
+    {
+        resBool = db->rollback();
+        return 0;
+    }
+
+
+
+    queryStr = QString("SELECT reports.report_id "
+                                                 "FROM public.reports "
+                                                 "WHERE fk_task_fim_id = %1 "
+                                                 "ORDER BY reports.report_id ASC").arg(
+                                                        QString::number(id_task));
+
+    int report_id = 0;
+
+    QSqlQuery queryReportsSEL = QSqlQuery(*db);
+    if(queryExec(queryStr, &queryReportsSEL))
+    {
+        if (queryReportsSEL.first())
+        {//Отчет
+            report_id = queryReportsSEL.value(0).toInt();
+        }
+    }
+    else
+    {
+        resBool = db->rollback();
+        return 0;
+    }
+
+
+    queryStr = QString("DELETE FROM public.report_items "
+                                                 "WHERE fk_report_id = %1 ").arg(
+                                                        QString::number(report_id));
+
+    QSqlQuery queryItemsDEL = QSqlQuery(*db);
+    if(!queryExec(queryStr, &queryItemsDEL))
+    {
+        resBool = db->rollback();
+        return 0;
+    }
+
+    queryStr = QString("DELETE FROM public.reports "
+                                                 "WHERE report_id = %1 ").arg(
+                                                        QString::number(report_id));
+
+    QSqlQuery queryReportsDEL = QSqlQuery(*db);
+    if(!queryExec(queryStr, &queryReportsDEL))
+    {
+        resBool = db->rollback();
+        return 0;
+    }
+
+
+
+    queryStr = QString("DELETE FROM public.tasks_fim "
+                                                 "WHERE task_id = %1 "
+                                                 "RETURNING tasks_fim.task_id").arg(
+                                                        QString::number(id_task));
+
+    if(!queryExecInt(queryStr))
+    {
+        resBool = db->rollback();
+        return 0;
+    }
+
+    resBool = db->commit();
+    return id_trainee;
+}
+
+QList<TaskAmmFim> DataBaseLMS::selectTasksFIMofTrainee(int id_trainee)
+{
+    QList<TaskAmmFim> listTasks;
+    QString queryStr;
+    bool resBool = false;
+
+    resBool = db->transaction();
+
+    queryStr = QString("SELECT tasks_fim.task_id, tasks_fim.title, tasks_fim.status, "
+                                                 "users.user_id "
+                                                 "FROM public.tasks_fim JOIN public.users ON users.user_id = tasks_fim.fk_trainee_id "
+                                                 "WHERE tasks_fim.fk_trainee_id = %1 "
+                                                 "ORDER BY tasks_fim.task_id ASC").arg(
+                                                        id_trainee);
+
+    QSqlQuery query = QSqlQuery(*db);
+
+    if(queryExec(queryStr, &query))
+    {
+        while (query.next())
+        {//Задача
+            TaskAmmFim task;
+
+            task.setID(query.value(0).toInt());
+            task.title = query.value(1).toString();
+            task.status = query.value(2).toString();
+
+            //Выгребаем все malfunction для этой задачи
+            queryStr = QString("SELECT malfunctions.malfunction_id, malfunctions.num, malfunctions.dm_code, malfunctions.description, "
+                                                         "tasks_fim.task_id "
+                                                         "FROM public.malfunctions JOIN public.tasks_fim ON tasks_fim.task_id = malfunctions.fk_task_fim_id "
+                                                         "WHERE malfunctions.fk_task_fim_id = %1 "
+                                                         "ORDER BY malfunctions.num ASC").arg(
+                                                                task.getID());
+
+            QSqlQuery queryMalf = QSqlQuery(*db);
+
+            if(queryExec(queryStr, &queryMalf))
+            {
+                while (queryMalf.next())
+                {//Неисправность
+                    Malfunction malfanction;
+                    int malfunction_id = 0;
+
+                    malfunction_id = queryMalf.value(0).toString().toInt();
+                    malfanction.num = queryMalf.value(1).toString();
+                    malfanction.dmCode = queryMalf.value(2).toString();
+                    malfanction.description = queryMalf.value(3).toString();
+
+                    //Выгребаем сигналы для этой неисправности
+                    queryStr = QString("SELECT malf_signs.sign_id, malf_signs.type, malf_signs.description "
+                                                                 "FROM public.malf_signs "
+                                                                 "WHERE fk_malfunction_id = %1 "
+                                                                 "ORDER BY malf_signs.sign_id ASC").arg(
+                                                                        QString::number(malfunction_id));
+
+                    QSqlQuery querySign = QSqlQuery(*db);
+                    if(queryExec(queryStr, &querySign))
+                    {
+                        while (querySign.next())
+                        {//Сигналы
+                            MalfunctionSign sign;
+                            sign.type = querySign.value(1).toString().toInt();
+                            sign.description = querySign.value(2).toString();
+
+                            malfanction.malfunctionSigns.append(sign);
+                        };
+                    }
+
+                    task.addMalfunction(malfanction);
+                };
+            }
+            else
+            {
+                resBool = db->rollback();
+                return QList<TaskAmmFim>();
+            }
+
+
+            //Выгребаем отчет для этой задачи
+            int report_id = 0;
+            queryStr = QString("SELECT reports.report_id "
+                                                         "FROM public.reports "
+                                                         "WHERE fk_task_fim_id = %1 "
+                                                         "ORDER BY reports.report_id ASC").arg(
+                                                                QString::number(task.getID()));
+
+            QSqlQuery queryReport = QSqlQuery(*db);
+
+            if(queryExec(queryStr, &queryReport))
+            {
+                if (queryReport.first())
+                {//Отчет
+                    report_id = queryReport.value(0).toInt();
+                    task.report.id = report_id;
+                }
+            }
+            else
+            {
+                resBool = db->rollback();
+                return QList<TaskAmmFim>();
+            }
+
+            if(report_id)
+            {//Отчет есть
+                //Выгребаем все item отчета
+
+                queryStr = QString("SELECT report_items.item_id, report_items.text, report_items.doc, report_items.dm_code, report_items.title, report_items.result, report_items.fk_report_id, report_items.number "
+                                                             "FROM public.report_items "
+                                                             "WHERE fk_report_id = %1 "
+                                                             "ORDER BY report_items.number ASC").arg(
+                                                                      QString::number(report_id));
+
+                QSqlQuery queryItems = QSqlQuery(*db);
+
+                if(queryExec(queryStr, &queryItems))
+                {
+                    while (queryItems.next())
+                    {//report_item
+                        FIMReportItem reportItem;
+                        reportItem.id = queryItems.value(0).toInt();
+                        reportItem.text = queryItems.value(1).toString();
+                        reportItem.procedure.doc = queryItems.value(2).toString();
+                        reportItem.procedure.dmCode = queryItems.value(3).toString();
+                        reportItem.procedure.title = queryItems.value(4).toString();
+                        reportItem.procedure.result = queryItems.value(5).toString();
+                        //item_report
+                        //number
+
+                        task.report.itemList.append(reportItem);
+                    }
+                }
+                else
+                {
+                    resBool = db->rollback();
+                    return QList<TaskAmmFim>();
+                }
+            }
+
+            listTasks.append(task);
+        };
+    }
+    else
+    {
+        resBool = db->rollback();
+        return QList<TaskAmmFim>();
+    }
+
+    resBool = db->commit();
+    return listTasks;
+}
+
+TaskAmmFim DataBaseLMS::selectTaskFIMbyID(int id_task)
+{
+    TaskAmmFim task;
+
+    QString queryStr;
+    bool resBool = false;
+
+    resBool = db->transaction();
+
+    queryStr = QString("SELECT tasks_fim.task_id, tasks_fim.title, tasks_fim.status "
+                                                 "FROM public.tasks_fim "
+                                                 "WHERE tasks_fim.task_id = %1 "
+                                                 "ORDER BY tasks_fim.task_id ASC").arg(
+                                                        id_task);
+
+    QSqlQuery query = QSqlQuery(*db);
+
+    if(queryExec(queryStr, &query))
+    {
+        if(query.first())
+        {//Задача
+
+            task.setID(query.value(0).toInt());
+            task.title = query.value(1).toString();
+            task.status = query.value(2).toString();
+
+            //Выгребаем все malfunction для этой задачи
+            queryStr = QString("SELECT malfunctions.malfunction_id, malfunctions.num, malfunctions.dm_code, malfunctions.description, "
+                                                         "tasks_fim.task_id "
+                                                         "FROM public.malfunctions JOIN public.tasks_fim ON tasks_fim.task_id = malfunctions.fk_task_fim_id "
+                                                         "WHERE malfunctions.fk_task_fim_id = %1 "
+                                                         "ORDER BY malfunctions.num ASC").arg(
+                                                                task.getID());
+
+            QSqlQuery queryMalf = QSqlQuery(*db);
+
+            if(queryExec(queryStr, &queryMalf))
+            {
+                while (queryMalf.next())
+                {//Неисправность
+                    Malfunction malfanction;
+                    int malfunction_id = 0;
+
+                    malfunction_id = queryMalf.value(0).toString().toInt();
+                    malfanction.num = queryMalf.value(1).toString();
+                    malfanction.dmCode = queryMalf.value(2).toString();
+                    malfanction.description = queryMalf.value(3).toString();
+
+                    //Выгребаем сигналы для этой неисправности
+                    queryStr = QString("SELECT malf_signs.sign_id, malf_signs.type, malf_signs.description "
+                                                                 "FROM public.malf_signs "
+                                                                 "WHERE fk_malfunction_id = %1 "
+                                                                 "ORDER BY malf_signs.sign_id ASC").arg(
+                                                                        QString::number(malfunction_id));
+
+                    QSqlQuery querySign = QSqlQuery(*db);
+                    if(queryExec(queryStr, &querySign))
+                    {
+                        while (querySign.next())
+                        {//Сигналы
+                            MalfunctionSign sign;
+                            sign.type = querySign.value(1).toString().toInt();
+                            sign.description = querySign.value(2).toString();
+
+                            malfanction.malfunctionSigns.append(sign);
+                        };
+                    }
+
+                    task.addMalfunction(malfanction);
+                };
+            }
+            else
+            {
+                resBool = db->rollback();
+                return task;
+            }
+
+
+            //Выгребаем отчет для этой задачи
+            int report_id = 0;
+            queryStr = QString("SELECT reports.report_id "
+                                                         "FROM public.reports "
+                                                         "WHERE fk_task_fim_id = %1 "
+                                                         "ORDER BY reports.report_id ASC").arg(
+                                                                QString::number(task.getID()));
+
+            QSqlQuery queryReport = QSqlQuery(*db);
+
+            if(queryExec(queryStr, &queryReport))
+            {
+                if (queryReport.first())
+                {//Отчет
+                    report_id = queryReport.value(0).toInt();
+                    task.report.id = report_id;
+                }
+            }
+            else
+            {
+                resBool = db->rollback();
+                return task;
+            }
+
+            if(report_id)
+            {//Отчет есть
+                //Выгребаем все item отчета
+
+                queryStr = QString("SELECT report_items.item_id, report_items.text, report_items.doc, report_items.dm_code, report_items.title, report_items.result, report_items.fk_report_id, report_items.number "
+                                                             "FROM public.report_items "
+                                                             "WHERE fk_report_id = %1 "
+                                                             "ORDER BY report_items.number ASC").arg(
+                                                                      QString::number(report_id));
+
+                QSqlQuery queryItems = QSqlQuery(*db);
+
+                if(queryExec(queryStr, &queryItems))
+                {
+                    while (queryItems.next())
+                    {//report_item
+                        FIMReportItem reportItem;
+                        reportItem.id = queryItems.value(0).toInt();
+                        reportItem.text = queryItems.value(1).toString();
+                        reportItem.procedure.doc = queryItems.value(2).toString();
+                        reportItem.procedure.dmCode = queryItems.value(3).toString();
+                        reportItem.procedure.title = queryItems.value(4).toString();
+                        reportItem.procedure.result = queryItems.value(5).toString();
+                        //item_report
+                        //number
+
+                        task.report.itemList.append(reportItem);
+                    }
+                }
+                else
+                {
+                    resBool = db->rollback();
+                    return task;
+                }
+            }
+        };
+    }
+    else
+    {
+        resBool = db->rollback();
+        return task;
+    }
+
+    resBool = db->commit();
+    return task;
+}
+
+int DataBaseLMS::updateReportFIMforTask(TaskAmmFim task)
+{
+    QString queryStr;
+    bool resBool = false;
+    int report_id = 0;
+    int task_id = task.getID();
+
+    resBool = db->transaction();
+
+    queryStr = QString("SELECT reports.report_id "
+                                                 "FROM public.reports "
+                                                 "WHERE fk_task_fim_id = %1 "
+                                                 "ORDER BY reports.report_id ASC").arg(
+                                                        QString::number(task_id));
+
+    QSqlQuery queryReportsSEL = QSqlQuery(*db);
+
+    if(queryExec(queryStr, &queryReportsSEL))
+    {
+        if (queryReportsSEL.first())
+        {//Отчет
+            report_id = queryReportsSEL.value(0).toInt();
+        }
+    }
+    else
+    {
+        resBool = db->rollback();
+        return 0;
+    }
+
+    if(!report_id)
+    {
+        queryStr = QString("INSERT INTO public.reports (fk_task_fim_id) "
+                                                     "VALUES (%1) "
+                                                     "RETURNING reports.report_id").arg(
+                                                            task.getID());
+
+        report_id = queryExecInt(queryStr);
+        if(!report_id)
+        {
+            resBool = db->rollback();
+            return 0;
+        }
+    }
+    else
+    {
+        queryStr = QString("DELETE FROM public.report_items "
+                                                     "WHERE fk_report_id = %1 ").arg(
+                                                            QString::number(report_id));
+
+        QSqlQuery queryItemsDEL = QSqlQuery(*db);
+        if(!queryExec(queryStr, &queryItemsDEL))
+        {
+            resBool = db->rollback();
+            return 0;
+        }
+    }
+
+    int number = 0;
+    for(FIMReportItem reportItem : task.report.itemList)
+    {
+        queryStr = QString("INSERT INTO public.report_items (text, doc, dm_code, title, result, fk_report_id, number) "
+                                                     "VALUES ('%1', '%2', '%3', '%4', '%5', %6, %7) "
+                                                     "RETURNING report_items.item_id").arg(
+                                                            reportItem.text,
+                                                            reportItem.procedure.doc,
+                                                            reportItem.procedure.dmCode,
+                                                            reportItem.procedure.title,
+                                                            reportItem.procedure.result,
+                                                            QString::number(report_id),
+                                                            QString::number(++number));
+
+        if(!queryExecInt(queryStr))
+        {
+            resBool = db->rollback();
+            return 0;
+        }
+    }
+
+    queryStr = QString("UPDATE public.tasks_fim SET status = '%1' "
+                                                 "WHERE task_id = %2 ").arg(
+                                                        "checkup",
+                                                        QString::number(task_id) );
+
+    QSqlQuery queryTaskUPD = QSqlQuery(*db);
+    if(!queryExec(queryStr, &queryTaskUPD))
+    {
+        resBool = db->rollback();
+        return 0;
+    }
+
+    resBool = db->commit();
+    return report_id;
+}

DataBaseLMS/databaselms_trainees.cpp

@@ -0,0 +1,468 @@
+#include "databaselms.h"
+
+#include <QtSql>
+#include <QSqlDatabase>
+#include <QSqlDriver>
+#include <QMessageBox>
+
+
+QList<Trainee> DataBaseLMS::selectAllTrainees()
+{
+    QList<Trainee> listTrainees;
+
+    QString queryStr = QString("SELECT users.user_id, users.name, users.login, users.password, users.archived, users.logged_in, "
+                                                 "groups.group_id, groups.name, "
+                                                 "computers.computer_id, computers.name, computers.ip_address, "
+                                                 "classrooms.classroom_id, classrooms.name "
+                                                 "FROM public.users JOIN public.groups ON groups.group_id = users.fk_group_id "
+                                                 "LEFT OUTER JOIN public.computers ON computers.computer_id = users.fk_computer_id "
+                                                 "LEFT OUTER JOIN public.classrooms ON classrooms.classroom_id = computers.fk_classroom_id "
+                                                 "WHERE users.type = '%1' "
+                                                 "ORDER BY groups.name, users.name ASC").arg(
+                                                    TypeUserDBTrainee);
+
+    QSqlQuery query = QSqlQuery(*db);
+
+    if(queryExec(queryStr, &query))
+    {
+        while (query.next())
+        {//Обучаемый
+            Trainee trainee;
+
+            trainee.setID(query.value(0).toInt());
+            trainee.setName(query.value(1).toString());
+            trainee.setLogin(query.value(2).toString());
+            trainee.setPassword(query.value(3).toString());
+            trainee.setArchived(query.value(4).toBool());
+            trainee.setLoggedIn(query.value(5).toBool());
+
+            Group group = Group(query.value(6).toInt(), query.value(7).toString());
+            trainee.setGroup(group);
+
+            Classroom classroom = Classroom(query.value(11).toInt(), query.value(12).toString());
+            Computer computer = Computer(query.value(8).toInt(), query.value(9).toString(), query.value(10).toString(), classroom);
+            trainee.setComputer(computer);
+
+            listTrainees.append(trainee);
+        }
+    }
+
+    return listTrainees;
+}
+
+Trainee DataBaseLMS::selectTrainee(int id_trainee)
+{
+    Trainee trainee;
+
+    QString queryStr = QString("SELECT users.user_id, users.name, users.login, users.password, users.archived, users.logged_in, "
+                                                 "groups.group_id, groups.name, "
+                                                 "computers.computer_id, computers.name, computers.ip_address, "
+                                                 "classrooms.classroom_id, classrooms.name "
+                                                 "FROM public.users JOIN public.groups ON groups.group_id = users.fk_group_id "
+                                                 "LEFT OUTER JOIN public.computers ON computers.computer_id = users.fk_computer_id "
+                                                 "LEFT OUTER JOIN public.classrooms ON classrooms.classroom_id = computers.fk_classroom_id "
+                                                 "WHERE users.user_id = %1 AND users.type = '%2' "
+                                                 "ORDER BY groups.name, users.name ASC").arg(
+                                                        QString::number(id_trainee),
+                                                        TypeUserDBTrainee);
+
+    QSqlQuery query = QSqlQuery(*db);
+
+    if(queryExec(queryStr, &query))
+    {
+        if (query.first())
+        {//Обучаемый
+            trainee.setID(query.value(0).toInt());
+            trainee.setName(query.value(1).toString());
+            trainee.setLogin(query.value(2).toString());
+            trainee.setPassword(query.value(3).toString());
+            trainee.setArchived(query.value(4).toBool());
+            trainee.setLoggedIn(query.value(5).toBool());
+
+            Group group = Group(query.value(6).toInt(), query.value(7).toString());
+            trainee.setGroup(group);
+
+            Classroom classroom = Classroom(query.value(11).toInt(), query.value(12).toString());
+            Computer computer = Computer(query.value(8).toInt(), query.value(9).toString(), query.value(10).toString(), classroom);
+            trainee.setComputer(computer);
+        }
+    }
+
+    return trainee;
+}
+
+QList<Trainee> DataBaseLMS::selectAllTraineesInGroup(int id_group)
+{
+    QList<Trainee> listTrainees;
+
+    QString queryStr = QString("SELECT users.user_id, users.name, users.login, users.password, users.archived, users.logged_in, "
+                                                 "groups.group_id, groups.name, "
+                                                 "computers.computer_id, computers.name, computers.ip_address, "
+                                                 "classrooms.classroom_id, classrooms.name "
+                                                 "FROM public.users JOIN public.groups ON groups.group_id = users.fk_group_id "
+                                                 "LEFT OUTER JOIN public.computers ON computers.computer_id = users.fk_computer_id "
+                                                 "LEFT OUTER JOIN public.classrooms ON classrooms.classroom_id = computers.fk_classroom_id "
+                                                 "WHERE users.fk_group_id = %1 AND users.type = '%2' "
+                                                 "ORDER BY groups.name, users.name ASC").arg(
+                                                        QString::number(id_group),
+                                                        TypeUserDBTrainee);
+
+    QSqlQuery query = QSqlQuery(*db);
+
+    if(queryExec(queryStr, &query))
+    {
+        while (query.next())
+        {//Обучаемый
+            Trainee trainee;
+
+            trainee.setID(query.value(0).toInt());
+            trainee.setName(query.value(1).toString());
+            trainee.setLogin(query.value(2).toString());
+            trainee.setPassword(query.value(3).toString());
+            trainee.setArchived(query.value(4).toBool());
+            trainee.setLoggedIn(query.value(5).toBool());
+
+            Group group = Group(query.value(6).toInt(), query.value(7).toString());
+            trainee.setGroup(group);
+
+            Classroom classroom = Classroom(query.value(11).toInt(), query.value(12).toString());
+            Computer computer = Computer(query.value(8).toInt(), query.value(9).toString(), query.value(10).toString(), classroom);
+            trainee.setComputer(computer);
+
+            listTrainees.append(trainee);
+        }
+    }
+
+    return listTrainees;
+}
+
+QString DataBaseLMS::selectTraineeNameOnComputer(QString computer_name)
+{
+    QString queryStr = QString("SELECT users.name "
+                                                 "FROM public.users JOIN public.computers ON computers.computer_id = users.fk_computer_id "
+                                                 "WHERE computers.name = '%1' AND users.type = '%2' ").arg(
+                                                        computer_name,
+                                                        TypeUserDBTrainee);
+
+    return queryExecString(queryStr);
+}
+
+Trainee DataBaseLMS::selectTraineeOnComputer(QString computer_name)
+{
+    Trainee trainee;
+
+    QString queryStr = QString("SELECT users.trainee_id, users.name, users.login, users.password, users.archived, users.logged_in, "
+                                                 "groups.group_id, groups.name, "
+                                                 "computers.computer_id, computers.name, computers.ip_address, "
+                                                 "classrooms.classroom_id, classrooms.name "
+                                                 "FROM public.users JOIN public.groups ON groups.group_id = users.fk_group_id "
+                                                 "LEFT OUTER JOIN public.computers ON computers.computer_id = users.fk_computer_id "
+                                                 "LEFT OUTER JOIN public.classrooms ON classrooms.classroom_id = computers.fk_classroom_id "
+                                                 "WHERE computers.name = '%1' AND users.type = '%2' ").arg(
+                                                        computer_name,
+                                                        TypeUserDBTrainee);
+
+    QSqlQuery query = QSqlQuery(*db);
+
+    if(queryExec(queryStr, &query))
+    {
+        if (query.first())
+        {//Обучаемый
+            trainee.setID(query.value(0).toInt());
+            trainee.setName(query.value(1).toString());
+            trainee.setLogin(query.value(2).toString());
+            trainee.setPassword(query.value(3).toString());
+            trainee.setArchived(query.value(4).toBool());
+            trainee.setLoggedIn(query.value(5).toBool());
+
+            Group group = Group(query.value(6).toInt(), query.value(7).toString());
+            trainee.setGroup(group);
+
+            Classroom classroom = Classroom(query.value(11).toInt(), query.value(12).toString());
+            Computer computer = Computer(query.value(8).toInt(), query.value(9).toString(), query.value(10).toString(), classroom);
+            trainee.setComputer(computer);
+        }
+    }
+
+    return trainee;
+}
+
+int DataBaseLMS::insertTrainee(int id_group)
+{
+    QString queryStr = QString("INSERT INTO public.users (type, name, login, password, archived, logged_in, fk_group_id) "
+                                                 "VALUES ('%1', DEFAULT, DEFAULT, DEFAULT, DEFAULT, DEFAULT, %2) "
+                                                 "RETURNING users.user_id").arg(
+                                                        TypeUserDBTrainee,
+                                                        QString::number(id_group));
+
+    return queryExecInt(queryStr);
+}
+
+int DataBaseLMS::insertTrainee(Trainee trainee)
+{
+    QString queryStr = QString("INSERT INTO public.users (type, name, login, password, archived, logged_in, fk_group_id) "
+                                                 "VALUES ('%1', '%2', '%3', '%4', %5, %6, %7) "
+                                                 "RETURNING users.user_id").arg(
+                                                        TypeUserDBTrainee,
+                                                        trainee.getName(),
+                                                        trainee.getLogin(),
+                                                        trainee.getPassword(),
+                                                        trainee.getArchived() ? "true" : "false",
+                                                        trainee.getLoggedIn() ? "true" : "false",
+                                                        QString::number(trainee.getGroup().getID()));
+
+    return queryExecInt(queryStr);
+}
+
+int DataBaseLMS::deleteTrainee(int id_trainee)
+{
+    QString queryStr;
+    int res = 0;
+    bool resBool = false;
+
+    resBool = db->transaction();
+
+
+    //Удаление задач AMM
+    queryStr = QString("DELETE FROM public.tasks_amm "
+                                                     "WHERE fk_trainee_id = %1 ").arg(
+                                                            QString::number(id_trainee));
+
+    QSqlQuery queryTasksAMMDEL = QSqlQuery(*db);
+    if(!queryExec(queryStr, &queryTasksAMMDEL))
+    {
+        resBool = db->rollback();
+        return 0;
+    }
+
+
+    //Удаление задач FIM
+
+    /*Выборка задач FIM для этого обучаемого*/
+    queryStr = QString("SELECT tasks_fim.task_id "
+                                                 "FROM public.tasks_fim "
+                                                 "WHERE tasks_fim.fk_trainee_id = %1 "
+                                                 "ORDER BY tasks_fim.task_id ASC").arg(
+                                                        id_trainee);
+
+    QSqlQuery queryTasksFIMSEL = QSqlQuery(*db);
+    if(queryExec(queryStr, &queryTasksFIMSEL))
+    {
+        while (queryTasksFIMSEL.next())
+        {//Задача
+            int task_id = queryTasksFIMSEL.value(0).toInt();
+
+            /*Выборка неисправностей для этой задачи*/
+            queryStr = QString("SELECT malfunctions.malfunction_id "
+                                                         "FROM public.malfunctions "
+                                                         "WHERE malfunctions.fk_task_fim_id = %1 "
+                                                         "ORDER BY malfunctions.malfunction_id ASC").arg(
+                                                                task_id);
+
+            QSqlQuery queryMulfSEL = QSqlQuery(*db);
+            if(queryExec(queryStr, &queryMulfSEL))
+            {
+                while (queryMulfSEL.next())
+                {//Неисправность
+                    int mulf_id = queryMulfSEL.value(0).toInt();
+
+                    /*Удаление сигналов для этой неисправности*/
+                    queryStr = QString("DELETE FROM public.malf_signs "
+                                                                     "WHERE malf_signs.fk_malfunction_id = %1 ").arg(
+                                                                            mulf_id);
+                    QSqlQuery querySign = QSqlQuery(*db);
+                    if(!queryExec(queryStr, &querySign))
+                    {
+                        resBool = db->rollback();
+                        return 0;
+                    }
+                };
+
+            }
+            else
+            {
+                resBool = db->rollback();
+                return 0;
+            }
+
+            /*Удаление неисправностей*/
+            queryStr = QString("DELETE FROM public.malfunctions "
+                                                             "WHERE malfunctions.fk_task_fim_id = %1 ").arg(
+                                                                    task_id);
+            QSqlQuery queryMulfDEL = QSqlQuery(*db);
+            if(!queryExec(queryStr, &queryMulfDEL))
+            {
+                resBool = db->rollback();
+                return 0;
+            }
+
+            /*Удаление отчетов для задачи*/
+            /*Выборка отчетов для этой задачи*/
+            queryStr = QString("SELECT reports.report_id "
+                                                         "FROM public.reports "
+                                                         "WHERE reports.fk_task_fim_id = %1 "
+                                                         "ORDER BY reports.report_id ASC").arg(
+                                                                task_id);
+            QSqlQuery queryReportsSEL = QSqlQuery(*db);
+            if(queryExec(queryStr, &queryReportsSEL))
+            {
+                while (queryReportsSEL.next())
+                {//отчет
+                    int report_id = queryReportsSEL.value(0).toInt();
+
+                    /*Удаление items для этого отчета*/
+                    queryStr = QString("DELETE FROM public.report_items "
+                                                                     "WHERE report_items.fk_report_id = %1 ").arg(
+                                                                            report_id);
+                    QSqlQuery queryReportDEL = QSqlQuery(*db);
+                    if(!queryExec(queryStr, &queryReportDEL))
+                    {
+                        resBool = db->rollback();
+                        return 0;
+                    }
+                };
+
+            }
+            else
+            {
+                resBool = db->rollback();
+                return 0;
+            }
+
+            /*Удаление отчетов*/
+            queryStr = QString("DELETE FROM public.reports "
+                                                             "WHERE reports.fk_task_fim_id = %1 ").arg(
+                                                                    task_id);
+            QSqlQuery queryReportsDEL = QSqlQuery(*db);
+            if(!queryExec(queryStr, &queryReportsDEL))
+            {
+                resBool = db->rollback();
+                return 0;
+            }
+            // ////////////////////////////
+        };
+    }
+    else
+    {
+        resBool = db->rollback();
+        return 0;
+    }
+
+    /*Удаление непосредственно задач FIM*/
+    queryStr = QString("DELETE FROM public.tasks_fim "
+                                                     "WHERE fk_trainee_id = %1 ").arg(
+                                                            QString::number(id_trainee));
+
+    QSqlQuery queryTasksFIMDEL = QSqlQuery(*db);
+    if(!queryExec(queryStr, &queryTasksFIMDEL))
+    {
+        resBool = db->rollback();
+        return 0;
+    }
+
+    /*Удаление таймингов для обучаемого*/
+    queryStr = QString("DELETE FROM public.timings "
+                                                     "WHERE fk_trainee_id = %1 ").arg(
+                                                            QString::number(id_trainee));
+
+    QSqlQuery queryTimingsDEL = QSqlQuery(*db);
+    if(!queryExec(queryStr, &queryTimingsDEL))
+    {
+        resBool = db->rollback();
+        return 0;
+    }
+    // ////////////////////////////
+
+
+    //Удаление обучаемого
+    queryStr = QString("DELETE FROM public.users "
+                                                 "WHERE user_id = %1 AND users.type = '%2' "
+                                                 "RETURNING users.user_id").arg(
+                                                        QString::number(id_trainee),
+                                                        TypeUserDBTrainee);
+
+    res = queryExecInt(queryStr);
+    if(res)
+    {
+        resBool = db->commit();
+        return res;
+    }
+    else
+    {
+        resBool = db->rollback();
+        return 0;
+    }
+}
+
+int DataBaseLMS::updateTrainee(Trainee trainee)
+{
+    QString computer_id = (trainee.getComputer().getID() == 0 ? QStringLiteral("null") : QString::number(trainee.getComputer().getID()));
+
+    QString queryStr = QString("UPDATE public.users "
+                                                 "SET name = '%1', login = '%2', password = '%3', archived = %4, logged_in = %5, "
+                                                 "fk_group_id = %6, "
+                                                 "fk_computer_id = %7 "
+                                                 "WHERE user_id = %8 AND users.type = '%9' "
+                                                 "RETURNING users.user_id").arg(
+                                                        trainee.getName(),
+                                                        trainee.getLogin(),
+                                                        trainee.getPassword(),
+                                                        trainee.getArchived() ? "true" : "false",
+                                                        trainee.getLoggedIn() ? "true" : "false",
+                                                        QString::number(trainee.getGroup().getID()),
+                                                        computer_id,
+                                                        QString::number(trainee.getID()),
+                                                        TypeUserDBTrainee);
+
+    return queryExecInt(queryStr);
+}
+
+int DataBaseLMS::insertTimingTrainee(int id_trainee)
+{
+    QString queryStr = QString("INSERT INTO public.timings (entry_time, exit_time, operating_time, fk_trainee_id) "
+                                                 "VALUES (DEFAULT, DEFAULT, DEFAULT, %1) "
+                                                 "RETURNING timings.timing_id").arg(
+                                                        QString::number(id_trainee));
+
+    return queryExecInt(queryStr);
+}
+
+int DataBaseLMS::updateTimingTrainee(int id_trainee, TimingOfTrainee timing)
+{
+    QString queryStr = QString("UPDATE public.timings "
+                                                 "SET entry_time = '%1', exit_time = '%2', operating_time = '%3', fk_trainee_id = %4 "
+                                                 "WHERE timing_id = %5 "
+                                                 "RETURNING timings.timing_id").arg(
+                                                        timing.getEntryTimeS(),
+                                                        timing.getExitTimeS(),
+                                                        timing.getOperatingTimeS(),
+                                                        QString::number(id_trainee),
+                                                        QString::number(timing.getID()) );
+
+    return queryExecInt(queryStr);
+}
+
+TimingOfTrainee DataBaseLMS::selectTimingTrainee(int id_trainee)
+{
+    TimingOfTrainee timing(id_trainee);
+
+    QString queryStr = QString("SELECT timings.timing_id, timings.entry_time, timings.exit_time, timings.operating_time, timings.fk_trainee_id "
+                                    "FROM public.timings "
+                                    "WHERE fk_trainee_id = '%1'").arg(id_trainee);
+
+    QSqlQuery querySel = QSqlQuery(*db);
+
+    if(queryExec(queryStr, &querySel))
+    {
+        if (querySel.first())
+        {//Тайминг
+            timing.setID(querySel.value(0).toInt());
+            timing.setEntryTime(querySel.value(1).toDateTime());
+            timing.setExitTime(querySel.value(2).toDateTime());
+            timing.setOperatingTime(querySel.value(3).toTime());
+            timing.setTraineeID(querySel.value(4).toInt());
+        }
+    }
+
+    return timing;
+}

DataBaseLMS/databaselms_users.cpp

@@ -0,0 +1,101 @@
+#include "databaselms.h"
+
+#include <QtSql>
+#include <QSqlDatabase>
+#include <QSqlDriver>
+#include <QMessageBox>
+
+int DataBaseLMS::selectUserID(QString type, QString login, QString password)
+{
+    QString queryStr;
+
+    if(password != QStringLiteral(""))
+    {
+        queryStr = QString("SELECT users.user_id "
+                                        "FROM public.users "
+                                        "WHERE login = '%1' AND password = '%2' AND users.type = '%3' ").arg(
+                                               login,
+                                               password,
+                                               type);
+    }
+    else
+    {
+        queryStr = QString("SELECT users.user_id "
+                                        "FROM public.users "
+                                        "WHERE login = '%1' AND users.type = '%2' ").arg(
+                                               login,
+                                               type);
+    }
+
+    return queryExecInt(queryStr);
+}
+
+QString DataBaseLMS::selectUserNameByLogin(QString type, QString login)
+{
+    QString queryStr = QString("SELECT users.name "
+                                                  "FROM public.users "
+                                                  "WHERE users.login = '%1' AND users.type = '%2' ").arg(
+                                                         login,
+                                                         type );
+
+    return queryExecString(queryStr);
+}
+
+bool DataBaseLMS::selectUserLoggedIn(QString type, int id_user)
+{
+    QString queryStr = QString("SELECT users.logged_in "
+                                                  "FROM public.users "
+                                                  "WHERE user_id = %1 AND users.type = '%2' ").arg(
+                                                         QString::number(id_user),
+                                                         type );
+
+    return queryExecBool(queryStr);
+}
+
+bool DataBaseLMS::selectUserArchived(QString type, int id_user)
+{
+    QString queryStr = QString("SELECT users.archived "
+                                                  "FROM public.users "
+                                                  "WHERE user_id = %1 AND users.type = '%2' ").arg(
+                                                        QString::number(id_user),
+                                                        type );
+
+    return queryExecBool(queryStr);
+}
+
+int DataBaseLMS::updateUserLoggedIn(QString type, int id_user, bool loggedIn)
+{
+    QString queryStr = QString("UPDATE public.users "
+                                                 "SET logged_in = %1 "
+                                                 "WHERE user_id = %2 AND users.type = '%3' "
+                                                 "RETURNING users.user_id").arg(
+                                                        loggedIn ? "true" : "false",
+                                                        QString::number(id_user),
+                                                        type);
+
+    return queryExecInt(queryStr);
+}
+
+bool DataBaseLMS::updateAllUsersLoggedIn(QString type, bool loggedIn)
+{
+    QString queryStr = QString("UPDATE public.users "
+                                                 "SET logged_in = %1 "
+                                                 "WHERE users.type = '%2' ").arg(
+                                                        loggedIn ? "true" : "false",
+                                                        type);
+
+    return queryExecBool(queryStr);
+}
+
+int DataBaseLMS::updateUserArchived(QString type, int id_user, bool archived)
+{
+    QString queryStr = QString("UPDATE public.users "
+                                                 "SET archived = %1 "
+                                                 "WHERE user_id = %2 AND users.type = '%3' "
+                                                 "RETURNING users.user_id").arg(
+                                                        archived ? "true" : "false",
+                                                        QString::number(id_user),
+                                                        type);
+
+    return queryExecInt(queryStr);
+}

DataBaseLMS/interfacedatabaselms.cpp

@@ -5,9 +5,10 @@
 #include <QTime>
 #include "interfacedatabaselms.h"
 
-InterfaceDataBaseLMS::InterfaceDataBaseLMS(QWidget* parent):
+InterfaceDataBaseLMS::InterfaceDataBaseLMS(QWidget *ownerWidget, QObject *parent):
-    QWidget(parent),
+    QObject(parent),
-    DataBaseLMS()
+    DataBaseLMS(ownerWidget),
+    ownerWidget(ownerWidget)
 {
 
 }
@@ -18,210 +19,171 @@ void InterfaceDataBaseLMS::slot_LanguageChanged(QString language)
     QCoreApplication::installTranslator(&qtLanguageTranslator);
 }
 
-bool InterfaceDataBaseLMS::ConnectionToDB()
+bool InterfaceDataBaseLMS::connectionToDB()
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     if(!createConnection())
     {
-        QMessageBox::critical(nullptr, dbSettings.dbName, tr("Connection error: ") + db->lastError().text());
+        QMessageBox::critical(ownerWidget, dbSettings.dbName, tr("Connection error: ") + db->lastError().text());
         return false;
     }
     else
     {
-        //QMessageBox::information(nullptr, dbName, tr("Connection is successful!"));
+        //QMessageBox::information(ownerWidget, dbName, tr("Connection is successful!"));
         return true;
     }
 }
 
-bool InterfaceDataBaseLMS::DisConnectionFromDB()
+bool InterfaceDataBaseLMS::disConnectionFromDB()
-{
+{    
+    //QMutexLocker mtxLocker(&mtxAccess);
     deleteConnection();
-    //QMessageBox::information(nullptr, dbName, tr("Disconnection is successful!"));
+    //QMessageBox::information(ownerWidget, dbName, tr("Disconnection is successful!"));
     return true;
 }
 
 bool InterfaceDataBaseLMS::DBisConnected()
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return isConnected();
 }
 
 
 //Инструкторы
 
-bool InterfaceDataBaseLMS::AuthorizationInstructor(QString login, QString password)
+bool InterfaceDataBaseLMS::authorizationInstructor(QString login, QString password)
 {
-    if(! transactionBegin())
+    //QMutexLocker mtxLocker(&mtxAccess);
-        return false;
 
-    if(int id = selectInstructorID(login, password))
+    if(int id = selectUserID(DataBaseLMS::TypeUserDBInstructor, login, password))
     {
-        if(isArchivedInstructor(id) || isLoggedInInstructor(id))
+        if(selectUserArchived(DataBaseLMS::TypeUserDBInstructor, id) || selectUserLoggedIn(DataBaseLMS::TypeUserDBInstructor, id))
-        {
-            transactionEnd();
             return false;
-        }
-        if(updateInstructorLoggedIn(id, true))
-            return transactionEnd();
-    }
 
-    transactionEnd();
+        if(updateUserLoggedIn(DataBaseLMS::TypeUserDBInstructor, id, true))
+            return true;
+    }
     return false;
 }
 
 bool InterfaceDataBaseLMS::deAuthorizationInstructor(QString login)
 {
-    if(! transactionBegin())
+    //QMutexLocker mtxLocker(&mtxAccess);
-        return false;
 
-    if(int id = selectInstructorID(login))
+    if(int id = selectUserID(DataBaseLMS::TypeUserDBInstructor, login))
     {
-        if(updateInstructorLoggedIn(id, false))
+        if(updateUserLoggedIn(DataBaseLMS::TypeUserDBInstructor, id, false))
-            return transactionEnd();
+            return true;
     }
-
-    transactionEnd();
     return false;
 }
 
 bool InterfaceDataBaseLMS::deAuthorizationAllInstructors()
 {
-    return updateAllInstructorsLoggedIn(false);
+    //QMutexLocker mtxLocker(&mtxAccess);
+    return updateAllUsersLoggedIn(DataBaseLMS::TypeUserDBInstructor, false);
 }
 
 QString InterfaceDataBaseLMS::getNameInstructorByLogin(QString login)
 {
-    return selectInstructorNameByLogin(login);
+    //QMutexLocker mtxLocker(&mtxAccess);
+    return selectUserNameByLogin(DataBaseLMS::TypeUserDBInstructor, login);
 }
 
 int InterfaceDataBaseLMS::getIdInstructorByLogin(QString login)
 {
-    return selectInstructorID(login);
+    //QMutexLocker mtxLocker(&mtxAccess);
+    return selectUserID(DataBaseLMS::TypeUserDBInstructor, login);
 }
 
 QList<Instructor> InterfaceDataBaseLMS::getListInstructors()
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return selectAllInstructors();
 }
 
 Instructor InterfaceDataBaseLMS::getInstructor(int id)
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return selectInstructor(id);
 }
 
 int InterfaceDataBaseLMS::newInstructor()
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return insertInstructor();
 }
 
 int InterfaceDataBaseLMS::delInstructor(int id)
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return deleteInstructor(id);
 }
 
 int InterfaceDataBaseLMS::editInstructor(Instructor instructor)
 {
-    //Проверка корректности логина, имени, пароля
+    //QMutexLocker mtxLocker(&mtxAccess);
-    QList<Instructor> listInstructors = selectAllInstructors();
-    for(Instructor exist_instructor : listInstructors)
-    {
-        if(instructor.getName() == QStringLiteral("<instructor>"))
-        {//Имя не корректно!
-            QMessageBox::critical(nullptr, tr("Editing error!"),
-                                  tr("Unacceptable instructor name has been entered.\nThe changes will not be accepted."));
-            return 0;
-        }
-
-        if(instructor.getLogin() == QStringLiteral("<login>"))
-        {//Логин не корректен!
-            QMessageBox::critical(nullptr, tr("Editing error!"),
-                                  tr("Unacceptable instructor login has been entered.\nThe changes will not be accepted."));
-            return 0;
-        }
-
-        if(instructor.getPassword() == QStringLiteral("<password>"))
-        {//Пароль не корректный!
-            QMessageBox::critical(nullptr, tr("Editing error!"),
-                                  tr("Unacceptable instructor password has been entered.\nThe changes will not be accepted."));
-            return 0;
-        }
-
-        if(instructor.getName() == exist_instructor.getName() && instructor.getID() != exist_instructor.getID())
-        {//Имя уже существует
-            QMessageBox::critical(nullptr, tr("Editing error!"),
-                                  tr("An existing instructor name has been entered."));
-            return 0;
-        }
-
-        if(instructor.getLogin() == exist_instructor.getLogin() && instructor.getID() != exist_instructor.getID())
-        {//Логин уже существует!
-            QMessageBox::critical(nullptr, tr("Editing error!"),
-                                  tr("An existing instructor login has been entered.\nThe changes will not be accepted."));
-            return 0;
-        }
-    }
-
     return updateInstructor(instructor);
 }
 
 bool InterfaceDataBaseLMS::isAdminInstructor(int id)
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return selectInstructorIsAdmin(id);
 }
 
 bool InterfaceDataBaseLMS::isArchivedInstructor(int id)
 {
-    return selectInstructorArchived(id);
+    //QMutexLocker mtxLocker(&mtxAccess);
+    return selectUserArchived(DataBaseLMS::TypeUserDBInstructor, id);
 }
 
 bool InterfaceDataBaseLMS::isLoggedInInstructor(int id)
 {
-    return selectInstructorLoggedIn(id);
+    //QMutexLocker mtxLocker(&mtxAccess);
+    return selectUserLoggedIn(DataBaseLMS::TypeUserDBInstructor, id);
 }
 
 
 //Инструкторы
 
-bool InterfaceDataBaseLMS::AuthorizationTrainee(QString login, QString password, QString classroom_name, QString computer_name)
+bool InterfaceDataBaseLMS::authorizationTrainee(QString login, QString password, QString classroom_name, QString computer_name)
 {
-    if(! transactionBegin())
+    //QMutexLocker mtxLocker(&mtxAccess);
-        return false;
 
-    if(int id = selectTraineeID(login, password))
+    if(int id = selectUserID(DataBaseLMS::TypeUserDBTrainee, login, password))
     {
-        if(isArchivedTrainee(id) || isLoggedInTrainee(id))
+        if(selectUserArchived(DataBaseLMS::TypeUserDBTrainee, id) || selectUserLoggedIn(DataBaseLMS::TypeUserDBTrainee, id))
-        {
-            transactionEnd();
             return false;
-        }
-        if(updateTraineeLoggedIn(id, true))
-            return transactionEnd();
-    }
 
-    transactionEnd();
+        if(updateUserLoggedIn(DataBaseLMS::TypeUserDBTrainee, id, true))
+            return true;
+    }
     return false;
 }
 
 bool InterfaceDataBaseLMS::deAuthorizationTrainee(QString login)
 {
-    if(! transactionBegin())
+    //QMutexLocker mtxLocker(&mtxAccess);
-        return false;
 
-    if(int id = selectTraineeID(login))
+    if(int id = selectUserID(DataBaseLMS::TypeUserDBTrainee, login))
     {
-        if(updateTraineeLoggedIn(id, false))
+        if(updateUserLoggedIn(DataBaseLMS::TypeUserDBTrainee, id, false))
-            return transactionEnd();
+            return true;
     }
-
-    transactionEnd();
     return false;
 }
 
 bool InterfaceDataBaseLMS::deAuthorizationAllTrainees()
 {
-    return updateAllTraineesLoggedIn(false);
+    //QMutexLocker mtxLocker(&mtxAccess);
+    return updateAllUsersLoggedIn(DataBaseLMS::TypeUserDBTrainee, false);
 }
 
 int InterfaceDataBaseLMS::entryTraineeOnSimulator(int id_trainee)
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
+
     TimingOfTrainee timing(id_trainee);
 
     timing = selectTimingTrainee(id_trainee);
@@ -242,6 +204,8 @@ int InterfaceDataBaseLMS::entryTraineeOnSimulator(int id_trainee)
 
 int InterfaceDataBaseLMS::exitTraineeFromSimulator(int id_trainee)
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
+
     TimingOfTrainee timing(id_trainee);
 
     timing = selectTimingTrainee(id_trainee);
@@ -262,218 +226,180 @@ int InterfaceDataBaseLMS::exitTraineeFromSimulator(int id_trainee)
 
 QString InterfaceDataBaseLMS::getNameTraineeOnComputer(QString computer_name)
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return selectTraineeNameOnComputer(computer_name);
 }
 
 Trainee InterfaceDataBaseLMS::getTraineeOnComputer(QString computer_name)
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return selectTraineeOnComputer(computer_name);
 }
 
 QString InterfaceDataBaseLMS::getNameTraineeByLogin(QString login)
 {
-    return selectTraineeNameByLogin(login);
+    //QMutexLocker mtxLocker(&mtxAccess);
+    return selectUserNameByLogin(DataBaseLMS::TypeUserDBTrainee, login);
 }
 
 int InterfaceDataBaseLMS::getIdTraineeByLogin(QString login)
 {
-    return selectTraineeID(login);
+    //QMutexLocker mtxLocker(&mtxAccess);
+    return selectUserID(DataBaseLMS::TypeUserDBTrainee, login);
 }
 
 QList<Trainee> InterfaceDataBaseLMS::getListTraineesInGroup(int id)
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return selectAllTraineesInGroup(id);
 }
 
 QList<Group> InterfaceDataBaseLMS::getListGroups()
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return selectAllGroups();
 }
 
 QList<Trainee> InterfaceDataBaseLMS::getListTrainees()
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return selectAllTrainees();
 }
 
 Trainee InterfaceDataBaseLMS::getTrainee(int id)
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return selectTrainee(id);
 }
 
 Group InterfaceDataBaseLMS::getGroup(int id)
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return selectGroup(id);
 }
 
 int InterfaceDataBaseLMS::newGroup()
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return insertGroup();
 }
 
 int InterfaceDataBaseLMS::delGroup(int id)
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return deleteGroup(id);
 }
 
 int InterfaceDataBaseLMS::editGroup(Group group)
 {
-    //Проверка корректности имени
+    //QMutexLocker mtxLocker(&mtxAccess);
-    QList<Group> listGroups = selectAllGroups();
-    for(Group exist_group : listGroups)
-    {
-        if(group.getName() == QStringLiteral("<group>"))
-        {//Имя не корректно!
-            QMessageBox::critical(nullptr, tr("Editing error!"),
-                                  tr("Unacceptable group name has been entered.\nThe changes will not be accepted."));
-            return 0;
-        }
-
-        if(group.getName() == exist_group.getName() && group.getID() != exist_group.getID())
-        {//Имя уже существует
-            QMessageBox::critical(nullptr, tr("Editing error!"),
-                                  tr("An existing group name has been entered.\nThe changes will not be accepted."));
-            return 0;
-        }
-    }
-
     return updateGroup(group);
 }
 
 int InterfaceDataBaseLMS::newTaskAMM(TaskAmmFim task, int id_trainee)
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return insertTaskAMM(task, id_trainee);
 }
 
 int InterfaceDataBaseLMS::delTaskAMM(int id)
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return deleteTaskAMM(id);
 }
 
 int InterfaceDataBaseLMS::editTaskAMM(TaskAmmFim task)
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return updateTaskAMM(task);
 }
 
 QList<TaskAmmFim> InterfaceDataBaseLMS::getListTasksAMMofTrainee(int id_trainee)
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return selectTasksAMMofTrainee(id_trainee);
 }
 
 QList<TaskAmmFim> InterfaceDataBaseLMS::getListTasksFIMofTrainee(int id_trainee)
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return selectTasksFIMofTrainee(id_trainee);
 }
 
 TaskAmmFim InterfaceDataBaseLMS::getTaskAMMbyID(int id_task)
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return selectTaskAMMbyID(id_task);
 }
 
 TaskAmmFim InterfaceDataBaseLMS::getTaskFIMbyID(int id_task)
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return selectTaskFIMbyID(id_task);
 }
 
 int InterfaceDataBaseLMS::newTaskFIM(TaskAmmFim task, int id_trainee)
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return insertTaskFIM(task, id_trainee);
 }
 
 int InterfaceDataBaseLMS::delTaskFIM(int id)
 {
-    deleteReportFIM(id);
+    //QMutexLocker mtxLocker(&mtxAccess);
     return deleteTaskFIM(id);
 }
 
 int InterfaceDataBaseLMS::editTaskFIM(TaskAmmFim task)
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return updateTaskFIM(task);
 }
 
 int InterfaceDataBaseLMS::replaceReportFIM(TaskAmmFim task)
 {
-    deleteReportFIM(task.getID());
+    //QMutexLocker mtxLocker(&mtxAccess);
-
+    return updateReportFIMforTask(task);
-    if(int report_id = insertReportFIM(task))
-    {
-        updateStatusTaskFIM(task.getID(), "checkup");
-        return report_id;
-    }
-
-    return 0;
 }
 
 int InterfaceDataBaseLMS::changeStatusTaskFIM(int id_task, QString status)
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return updateStatusTaskFIM(id_task, status);
 }
 
 int InterfaceDataBaseLMS::changeStatusTaskAMM(int id_task, QString status)
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return updateStatusTaskAMM(id_task, status);
 }
 
 int InterfaceDataBaseLMS::newTrainee(int id_group)
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return insertTrainee(id_group);
 }
 
 int InterfaceDataBaseLMS::delTrainee(int id)
 {
+    //QMutexLocker mtxLocker(&mtxAccess);
     return deleteTrainee(id);
 }
 
 int InterfaceDataBaseLMS::editTrainee(Trainee trainee)
 {
-    //Проверка корректности логина, имени, пароля
+    //QMutexLocker mtxLocker(&mtxAccess);
-    QList<Trainee> listTrainees = selectAllTrainees();
-    for(Trainee exist_trainee : listTrainees)
-    {
-        if(trainee.getName() == QStringLiteral("<trainee>"))
-        {//Имя не корректно!
-            QMessageBox::critical(nullptr, tr("Editing error!"),
-                                  tr("Unacceptable trainee name has been entered.\nThe changes will not be accepted."));
-            return 0;
-        }
-
-        if(trainee.getLogin() == QStringLiteral("<login>"))
-        {//Логин не корректен!
-            QMessageBox::critical(nullptr, tr("Editing error!"),
-                                  tr("Unacceptable trainee login has been entered.\nThe changes will not be accepted."));
-            return 0;
-        }
-
-        if(trainee.getPassword() == QStringLiteral("<password>"))
-        {//Пароль не корректный!
-            QMessageBox::critical(nullptr, tr("Editing error!"),
-                                  tr("Unacceptable trainee password has been entered.\nThe changes will not be accepted."));
-            return 0;
-        }
-
-        if(trainee.getName() == exist_trainee.getName() && trainee.getID() != exist_trainee.getID())
-        {//Имя уже существует
-            QMessageBox::critical(nullptr, tr("Editing error!"),
-                                  tr("An existing trainee name has been entered."));
-            return 0;
-        }
-
-        if(trainee.getLogin() == exist_trainee.getLogin() && trainee.getID() != exist_trainee.getID())
-        {//Логин уже существует!
-            QMessageBox::critical(nullptr, tr("Editing error!"),
-                                  tr("An existing trainee login has been entered.\nThe changes will not be accepted."));
-            return 0;
-        }
-    }
-
     return updateTrainee(trainee);
 }
 
 bool InterfaceDataBaseLMS::isArchivedTrainee(int id)
 {
-    return selectTraineeArchived(id);
+    //QMutexLocker mtxLocker(&mtxAccess);
+    return selectUserArchived(DataBaseLMS::TypeUserDBTrainee, id);
 }
 
 bool InterfaceDataBaseLMS::isLoggedInTrainee(int id)
 {
-    return selectTraineeLoggedIn(id);
+    //QMutexLocker mtxLocker(&mtxAccess);
+    return selectUserLoggedIn(DataBaseLMS::TypeUserDBTrainee, id);
 }

DataBaseLMS/interfacedatabaselms.h

@@ -8,25 +8,26 @@
 #include "DataBaseLMS_global.h"
 #include "databaselms.h"
 
-class DATABASELMS_EXPORT InterfaceDataBaseLMS : public /*QObject*/QWidget,  DataBaseLMS
+class DATABASELMS_EXPORT InterfaceDataBaseLMS : public QObject,  DataBaseLMS
 {
     Q_OBJECT
 
 public:
-    InterfaceDataBaseLMS(QWidget* parent = nullptr);
+    InterfaceDataBaseLMS(QWidget *ownerWidget, QObject *parent = nullptr);
 
 public Q_SLOTS:
     void slot_LanguageChanged(QString language);
 
 public:
     //Соединение
-    bool ConnectionToDB();
+    bool connectionToDB();
-    bool DisConnectionFromDB();
+    bool disConnectionFromDB();
     bool DBisConnected();
 
+
     //Инструкторы
 
-    bool AuthorizationInstructor(QString login, QString password);
+    bool authorizationInstructor(QString login, QString password);
     bool deAuthorizationInstructor(QString login);
     bool deAuthorizationAllInstructors();
 
@@ -47,7 +48,7 @@ public:
 
     //Обучаемые
 
-    bool AuthorizationTrainee(QString login, QString password, QString classroom_name, QString computer_name);
+    bool authorizationTrainee(QString login, QString password, QString classroom_name, QString computer_name);
     bool deAuthorizationTrainee(QString login);
     bool deAuthorizationAllTrainees();
 
@@ -55,9 +56,6 @@ public:
     int entryTraineeOnSimulator(int id_trainee);
     int exitTraineeFromSimulator(int id_trainee);
 
-
-    //void setTasks(QString login, QStringList tasks);
-
     QString getNameTraineeOnComputer(QString computer_name);
     Trainee getTraineeOnComputer(QString computer_name);
 
@@ -67,14 +65,26 @@ public:
     QList<Trainee> getListTraineesInGroup(int id);
     QList<Group> getListGroups();
     QList<Trainee> getListTrainees();
-
     Trainee getTrainee(int id);
-    Group getGroup(int group_id);
 
+    int newTrainee(int id_group);
+    int delTrainee(int id);
+    int editTrainee(Trainee trainee);
+
+    bool isArchivedTrainee(int id);
+    bool isLoggedInTrainee(int id);
+
+
+    //Группы
+
+    Group getGroup(int group_id);
     int newGroup();
     int delGroup(int id);
     int editGroup(Group group);
 
+
+    //Задачи
+
     int newTaskAMM(TaskAmmFim task, int id_trainee);
     int delTaskAMM(int id);
     int editTaskAMM(TaskAmmFim task);
@@ -92,15 +102,10 @@ public:
     int changeStatusTaskFIM(int id_task, QString status);
     int changeStatusTaskAMM(int id_task, QString status);
 
-    int newTrainee(int id_group);
-    int delTrainee(int id);
-    int editTrainee(Trainee trainee);
-
-    bool isArchivedTrainee(int id);
-    bool isLoggedInTrainee(int id);
-
 private:
     QTranslator qtLanguageTranslator;
+    QWidget* ownerWidget;
+    //QMutex mtxAccess;
 };
 
 #endif // INTERFACEDATABASELMS_H

DataBaseLMS/resources.qrc

@@ -0,0 +1,5 @@
+<RCC>
+    <qresource prefix="/">
+        <file>resources/blankXML/ErrorDB.xml</file>
+    </qresource>
+</RCC>

DataBaseLMS/resources/blankXML/ErrorDB.xml

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

InstructorsAndTrainees/connectorToServer/connectortoserver.cpp

@@ -295,6 +295,16 @@ int ConnectorToServer::getIdTraineeByLogin(QString login)
     return 0;
 }
 
+int ConnectorToServer::getIdInstructorByLogin(QString login)
+{
+    for(Instructor instructor : listInstructors)
+    {
+        if(instructor.getLogin() == login)
+            return instructor.getID();
+    }
+    return 0;
+}
+
 void ConnectorToServer::showVersionSelect()
 {
     QByteArray answer = dataParser->xmlAnswer_notify(cmd_CheckVersionList);

InstructorsAndTrainees/connectorToServer/connectortoserver.h

@@ -60,6 +60,7 @@ public:
     Group getGroup(int id);
 
     int getIdTraineeByLogin(QString login);
+    int getIdInstructorByLogin(QString login);
     void showVersionSelect();
 
     void setLoginName(QString name);

InstructorsAndTrainees/instructors/editorinstructors.cpp

@@ -270,7 +270,7 @@ bool EditorInstructors::verifyInstructor(Instructor instructor)
 {
     //Проверка корректности логина, имени, пароля
 
-    if(instructor.getName() == QStringLiteral("<instructor>"))
+    if(instructor.getName() == QStringLiteral("<name>"))
     {//Имя не корректно!
         QMessageBox::critical(this, tr("Editing error!"),
                               tr("Unacceptable instructor name has been entered.\nThe changes will not be accepted."));
@@ -292,23 +292,13 @@ bool EditorInstructors::verifyInstructor(Instructor instructor)
     }
 
 
-    QList<Instructor> listInstructors = connectorToServer->getListInstructors();
+    int user_I = connectorToServer->getIdInstructorByLogin(instructor.getLogin());
-
+    int user_T = connectorToServer->getIdTraineeByLogin(instructor.getLogin());
-    for(Instructor exist_instructor : listInstructors)
+    if((user_I && (user_I != instructor.getID())) ||  (user_T && (user_T != instructor.getID())))
-    {
+    {//Логин уже существует!
-        if(instructor.getName() == exist_instructor.getName() && instructor.getID() != exist_instructor.getID())
+        QMessageBox::critical(this, tr("Editing error!"),
-        {//Имя уже существует
+                              tr("An existing instructor or trainee login has been entered.\nThe changes will not be accepted."));
-            QMessageBox::critical(this, tr("Editing error!"),
+        return 0;
-                                  tr("An existing instructor name has been entered."));
-            return false;
-        }
-
-        if(instructor.getLogin() == exist_instructor.getLogin() && instructor.getID() != exist_instructor.getID())
-        {//Логин уже существует!
-            QMessageBox::critical(this, tr("Editing error!"),
-                                  tr("An existing instructor login has been entered.\nThe changes will not be accepted."));
-            return false;
-        }
     }
 
     return true;

InstructorsAndTrainees/trainees/editortrainees.cpp

@@ -24,6 +24,13 @@ EditorTrainees::EditorTrainees(ConnectorToServer* connectorToServer, bool adminM
         ui->btnArchive->click();
 
     waitAnimationWidget->setParent(this);
+
+    ui->btnNewGroup->setEnabled(true);
+    ui->btnDeleteGroup->setEnabled(false);
+    ui->btnNewTrainee->setEnabled(false);
+    ui->btnDeleteTrainee->setEnabled(false);
+    ui->btnToOrFromArchiveTrainee->setEnabled(false);
+    ui->btnEdit->setEnabled(false);
 }
 
 EditorTrainees::~EditorTrainees()
@@ -448,7 +455,7 @@ bool EditorTrainees::verifyTrainee(Trainee trainee)
 {
     //Проверка корректности логина, имени, пароля
 
-    if(trainee.getName() == QStringLiteral("<trainee>"))
+    if(trainee.getName() == QStringLiteral("<name>"))
     {//Имя не корректно!
         QMessageBox::critical(this, tr("Editing error!"),
                               tr("Unacceptable trainee name has been entered.\nThe changes will not be accepted."));
@@ -469,23 +476,14 @@ bool EditorTrainees::verifyTrainee(Trainee trainee)
         return false;
     }
 
-    QList<Trainee> listTrainees = connectorToServer->getListTrainees();
 
-    for(Trainee exist_trainee : listTrainees)
+    int user_I = connectorToServer->getIdInstructorByLogin(trainee.getLogin());
-    {
+    int user_T = connectorToServer->getIdTraineeByLogin(trainee.getLogin());
-        if(trainee.getName() == exist_trainee.getName() && trainee.getID() != exist_trainee.getID())
+    if((user_I && (user_I != trainee.getID())) ||  (user_T && (user_T != trainee.getID())))
-        {//Имя уже существует
+    {//Логин уже существует!
-            QMessageBox::critical(this, tr("Editing error!"),
+        QMessageBox::critical(this, tr("Editing error!"),
-                                  tr("An existing trainee name has been entered."));
+                              tr("An existing instructor or trainee login has been entered.\nThe changes will not be accepted."));
-            return false;
+        return 0;
-        }
-
-        if(trainee.getLogin() == exist_trainee.getLogin() && trainee.getID() != exist_trainee.getID())
-        {//Логин уже существует!
-            QMessageBox::critical(this, tr("Editing error!"),
-                                  tr("An existing trainee login has been entered.\nThe changes will not be accepted."));
-            return false;
-        }
     }
 
     return true;

ServerLMS/Systems/processingsystem.cpp

@@ -1,4 +1,5 @@
 #include "processingsystem.h"
+#include "providerdblms.h"
 
 #include <clienthandler.h>
 

ServerLMS/providerdblms.cpp

@@ -6,7 +6,7 @@ ProviderDBLMS::ProviderDBLMS(QWidget *parentWidget, QObject *parent) :
     QObject(parent),
     dbLMS(nullptr)
 {
-    dbLMS = new InterfaceDataBaseLMS(parentWidget);
+    dbLMS = new InterfaceDataBaseLMS(/*parentWidget*/nullptr);
     //ConnectionToDB();
 }
 
@@ -17,10 +17,10 @@ ProviderDBLMS::~ProviderDBLMS()
 
 void ProviderDBLMS::ConnectionToDB()
 {
-    mtxAccess.lock();
+   mtxAccess.lock();
    if(! dbLMS->DBisConnected())
    {
-       if(dbLMS->ConnectionToDB())
+       if(dbLMS->connectionToDB())
        {
            Q_EMIT signal_BlockAutorization(false);
            //Q_EMIT signal_NeedUpdateUI(true, true);
@@ -31,12 +31,12 @@ void ProviderDBLMS::ConnectionToDB()
 
 void ProviderDBLMS::DisConnectionFromDB()
 {
-     mtxAccess.lock();
+    mtxAccess.lock();
     if(dbLMS->DBisConnected())
     {
         Q_EMIT signal_BlockAutorization(true);
 
-        dbLMS->DisConnectionFromDB();
+        dbLMS->disConnectionFromDB();
 
         //Q_EMIT signal_NeedUpdateUI(true, true);
     }
@@ -72,7 +72,7 @@ bool ProviderDBLMS::authorizationTrainee(QString login, QString password, QStrin
 
     Q_EMIT signal_BlockAutorization(true);
 
-    bool res = dbLMS->AuthorizationTrainee(login, password, classroom_name, computer_name);
+    bool res = dbLMS->authorizationTrainee(login, password, classroom_name, computer_name);
 
     Q_EMIT signal_BlockAutorization(false);
 
@@ -134,7 +134,7 @@ bool ProviderDBLMS::authorizationInstructor(QString login, QString password)
 
     Q_EMIT signal_BlockAutorization(true);
 
-    bool res = dbLMS->AuthorizationInstructor(login, password);
+    bool res = dbLMS->authorizationInstructor(login, password);
 
     Q_EMIT signal_BlockAutorization(false);
 
@@ -224,18 +224,32 @@ bool ProviderDBLMS::deAuthorizationAll()
 
 bool ProviderDBLMS::entryTraineeOnSimulator(int id_trainee)
 {
+    mtxAccess.lock();
     if(dbLMS->entryTraineeOnSimulator(id_trainee))
+    {
+        mtxAccess.unlock();
         return true;
+    }
     else
+    {
+        mtxAccess.unlock();
         return false;
+    }
 }
 
 bool ProviderDBLMS::exitTraineeFromSimulator(int id_trainee)
 {
+    mtxAccess.lock();
     if(dbLMS->exitTraineeFromSimulator(id_trainee))
+    {
+        mtxAccess.unlock();
         return true;
+    }
     else
+    {
+        mtxAccess.unlock();
         return false;
+    }
 }
 
 int ProviderDBLMS::getIdTraineeByLogin(QString login)
@@ -348,92 +362,164 @@ QList<Group> ProviderDBLMS::GetListAllGroups()
 
 int ProviderDBLMS::newInstructor()
 {
-    return dbLMS->newInstructor();
+    int res = 0;
+    mtxAccess.lock();
+    res = dbLMS->newInstructor();
+    mtxAccess.unlock();
+    return res;
 }
 
 int ProviderDBLMS::delInstructor(int id)
 {
-    return dbLMS->delInstructor(id);
+    int res = 0;
+    mtxAccess.lock();
+    res = dbLMS->delInstructor(id);
+    mtxAccess.unlock();
+    return res;
 }
 
 int ProviderDBLMS::editInstructor(Instructor instructor)
 {
-    return dbLMS->editInstructor(instructor);
+    int res = 0;
+    mtxAccess.lock();
+    res = dbLMS->editInstructor(instructor);
+    mtxAccess.unlock();
+    return res;
 }
 
 int ProviderDBLMS::newTrainee(int id_group)
 {
-    return dbLMS->newTrainee(id_group);
+    int res = 0;
+    mtxAccess.lock();
+    res = dbLMS->newTrainee(id_group);
+    mtxAccess.unlock();
+    return res;
 }
 
 int ProviderDBLMS::delTrainee(int id)
 {
-    return dbLMS->delTrainee(id);
+    int res = 0;
+    mtxAccess.lock();
+    res = dbLMS->delTrainee(id);
+    mtxAccess.unlock();
+    return res;
 }
 
 int ProviderDBLMS::editTrainee(Trainee trainee)
 {
-    return dbLMS->editTrainee(trainee);
+    int res = 0;
+    mtxAccess.lock();
+    res = dbLMS->editTrainee(trainee);
+    mtxAccess.unlock();
+    return res;
 }
 
 int ProviderDBLMS::newGroup()
 {
-    return dbLMS->newGroup();
+    int res = 0;
+    mtxAccess.lock();
+    res = dbLMS->newGroup();
+    mtxAccess.unlock();
+    return res;
 }
 
 int ProviderDBLMS::delGroup(int id)
 {
-    return dbLMS->delGroup(id);
+    int res = 0;
+    mtxAccess.lock();
+    res = dbLMS->delGroup(id);
+    mtxAccess.unlock();
+    return res;
 }
 
 int ProviderDBLMS::editGroup(Group group)
 {
-    return dbLMS->editGroup(group);
+    int res = 0;
+    mtxAccess.lock();
+    res = dbLMS->editGroup(group);
+    mtxAccess.unlock();
+    return res;
 }
 
 int ProviderDBLMS::newTaskAMM(TaskAmmFim task, int id_trainee)
 {
-    return dbLMS->newTaskAMM(task, id_trainee);
+    int res = 0;
+    mtxAccess.lock();
+    res = dbLMS->newTaskAMM(task, id_trainee);
+    mtxAccess.unlock();
+    return res;
 }
 
 int ProviderDBLMS::delTaskAMM(int id)
 {
-    return dbLMS->delTaskAMM(id);
+    int res = 0;
+    mtxAccess.lock();
+    res = dbLMS->delTaskAMM(id);
+    mtxAccess.unlock();
+    return res;
 }
 
 int ProviderDBLMS::editTaskAMM(TaskAmmFim task)
 {
-    return dbLMS->editTaskAMM(task);
+    int res = 0;
+    mtxAccess.lock();
+    res = dbLMS->editTaskAMM(task);
+    mtxAccess.unlock();
+    return res;
 }
 
 int ProviderDBLMS::newTaskFIM(TaskAmmFim task, int id_trainee)
 {
-    return dbLMS->newTaskFIM(task, id_trainee);
+    int res = 0;
+    mtxAccess.lock();
+    res = dbLMS->newTaskFIM(task, id_trainee);
+    mtxAccess.unlock();
+    return res;
 }
 
 int ProviderDBLMS::delTaskFIM(int id)
 {
-    return dbLMS->delTaskFIM(id);
+    int res = 0;
+    mtxAccess.lock();
+    res = dbLMS->delTaskFIM(id);
+    mtxAccess.unlock();
+    return res;
 }
 
 int ProviderDBLMS::editTaskFIM(TaskAmmFim task)
 {
-    return dbLMS->editTaskFIM(task);
+    int res = 0;
+    mtxAccess.lock();
+    res = dbLMS->editTaskFIM(task);
+    mtxAccess.unlock();
+    return res;
 }
 
 int ProviderDBLMS::replaceReportFIM(TaskAmmFim task)
 {
-    return dbLMS->replaceReportFIM(task);
+    int res = 0;
+    mtxAccess.lock();
+    res = dbLMS->replaceReportFIM(task);
+    mtxAccess.unlock();
+    return res;
 }
 
 int ProviderDBLMS::changeStatusTaskFIM(int id_task, QString status)
 {
-    return dbLMS->changeStatusTaskFIM(id_task, status);
+    int res = 0;
+    mtxAccess.lock();
+    res = dbLMS->changeStatusTaskFIM(id_task, status);
+    mtxAccess.unlock();
+    return res;
 }
 
 int ProviderDBLMS::changeStatusTaskAMM(int id_task, QString status)
 {
-    return dbLMS->changeStatusTaskAMM(id_task, status);
+    int res = 0;
+    mtxAccess.lock();
+    res = dbLMS->changeStatusTaskAMM(id_task, status);
+    mtxAccess.unlock();
+    return res;
 }
 
 QList<TaskAmmFim> ProviderDBLMS::GetListTasksAMMofTrainee(int id_trainee)

ServerLMS/serverlmswidget.cpp

@@ -52,7 +52,7 @@ ServerLMSWidget::ServerLMSWidget(QWidget *parent) :
     updateController->moveToThread(updateThread);
 
     processingSystem = new ProcessingSystem(providerDBLMS, updateController);
-    processingSystem->moveToThread(updateThread);
+    //processingSystem->moveToThread(updateThread);
 
     dataParser = new DataParser(assetsManager,processingSystem);