Supervision.cpp

Aller à la documentation de ce fichier.

#include "Supervision.h"
#include "Ihm.h"
#include "Bdd.h"
#include "CodeBarre.h"
#include "Communication.h"
#include "Rfid.h"
#include "Utilisateur.h"
#include "Armoire.h"
#include "Article.h"
#include "Communication.h"
#include "Casier.h"
#include <QDate>
#include <QMessageBox>
#include <QCryptographicHash>

Supervision::Supervision(Ihm *parent) : QObject(parent), ihm(parent)
{
    // Instancie les objets dont la classe Supervision coordonne les actions
    bdd = Bdd::getInstance();
    bdd->connecter();
    codeBarre = new CodeBarre(this);
    //portSerie = new Communication(this);
    rfid = new Rfid(this);
    utilisateur = nullptr;
    armoire = new Armoire(this);    
    communication = new Communication(this);

    connecterSignauxSlots();

    communication->demarrerCommunicationPort();

    #ifdef SUPERVISION_TEST_POIDS
        QString trameTest = "CASIERS;3;1;2100";
        traiterTramePoids(trameTest);
    #endif

    //envoyer demande trame poids au démarrage pour mettre à jour le stock au démarrage
    communication->envoyerRequetePoids();
}

Supervision::~Supervision()
{

}

void Supervision::deconnecterUtilisateur()
{
    if(utilisateur != nullptr)
    {
        delete utilisateur;
        utilisateur = nullptr;
    }
}

void Supervision::creerCasiers()
{
    QString nbCasiers = armoire->getNbCasiers();
    qDebug() << Q_FUNC_INFO << "nbCasiers" << nbCasiers;
    if(!nbCasiers.isEmpty())
    {
        for(int i=0; i < nbCasiers.toInt(); i++)
        {
            Casier* casier = new Casier(i+1, ihm);
            casiers.push_back(casier);
            ihm->placerCasier(casier);
        }
    }
}

QStringList Supervision::getInformationsArmoire()
{
    QStringList informationsArmoire = armoire->getInformations();

    return informationsArmoire;
}

void Supervision::verifierAuthentificationBadge(QString badge)
{
    QString requeteBDD = "SELECT * from Utilisateur where Badge = '" + badge + "';";
    QStringList donnees = recupererDonneesUtilisateur(requeteBDD);
    if(verifierDonneesUtilisateur(donnees))
    {
        connecterUtilisateur(donnees);
    }
}

void Supervision::verifierAuthentificationIdentifiant(QString identifiant, QString motDePasse)
{
    this->crypterMotDepasse(motDePasse);

    #ifdef CHANGE_PASSWORD_BEFORE
    QString requete = QString("UPDATE Utilisateur SET MotDePasse='%1' WHERE Identifiant='%2'").arg(motDePasse).arg(identifiant);
    bdd->executer(requete);
    #endif

    QString requeteBDD = "SELECT * from Utilisateur where Identifiant =  '" + identifiant + "' && MotDePasse = '" + motDePasse + "';";
    QStringList donnees = recupererDonneesUtilisateur(requeteBDD);
    if(verifierDonneesUtilisateur(donnees))
    {
        connecterUtilisateur(donnees);
    }
}

QStringList Supervision::recupererDonneesUtilisateur(QString requeteBDD)
{
    QStringList donnees;
    bdd->recuperer(requeteBDD, donnees);

    return donnees;
}

void Supervision::crypterMotDepasse(QString &motDePasse)
{
    if(!motDePasse.isEmpty())
    {
    motDePasse = QString(QCryptographicHash::hash((motDePasse).toLatin1(), QCryptographicHash::Md5).toHex());
    }

    #ifdef DEBUG_SUPERVISION
        qDebug() << Q_FUNC_INFO << "Mot de passe crypte" << motDePasse;
    #endif
}

bool Supervision::verifierDateValidite(QString stringDateValidite)
{
    // Verification de la date de validité
    QDate dateValidite = dateValidite.fromString(stringDateValidite,"yyyy-MM-dd");
    QDate dateActuelle = QDate::currentDate();

    #ifdef DEBUG_SUPERVISION
        qDebug() << "Date actuelle" << dateActuelle;
        qDebug() << "Date validité" << dateValidite;
    #endif

    if(dateActuelle <= dateValidite)
    {
        return true;
    }

    return false;
}

bool Supervision::verifierDonneesUtilisateur(QStringList &donnees)
{
    #ifdef DEBUG_SUPERVISON
        qDebug() << Q_FUNC_INFO << donnees;
    #endif

    if(!donnees.isEmpty())
    {
        if(verifierDateValidite(donnees.at(TABLE_UTILISATEUR_DATE_VALIDITE)))
        {
            emit reponseDemandeDeConnexion(true, "");
            return true;
        }
        else
        {
            emit reponseDemandeDeConnexion(false, MESSAGE_ERREUR_UTILISATEUR_DATE_NON_VALIDE);
            return false;
        }
    }
    else
    {
        emit reponseDemandeDeConnexion(false, MESSAGE_ERREUR_UTILISATEUR_NON_VALIDE);
        return false;
    }
}

void Supervision::connecterUtilisateur(QStringList &donnees)
{
    if(utilisateur != nullptr)
    {
        deconnecterUtilisateur();
    }
    utilisateur = new Utilisateur(donnees, this);
    #ifdef DEBUG_SUPERVISION
        qDebug() << Q_FUNC_INFO << utilisateur->getIdentifiantUtilisateur() << "authentifié";
    #endif
}

void Supervision::connecterSignauxSlots()
{
    // Armoire
    connect(armoire, SIGNAL(informationsArmoire(QStringList)), ihm, SLOT(afficherInformationsArmoire(QStringList)));

    // Authentification Badge
    connect(ihm, SIGNAL(badgeDetecte(QString)), rfid, SLOT(traiterBadge(QString)));
    connect(rfid, SIGNAL(erreurBadgeInvalide(QString)), ihm, SLOT(afficherErreurBadge(QString)));
    connect(rfid, SIGNAL(nouveauUidBadge(QString)), this, SLOT(verifierAuthentificationBadge(QString)));

    // Authentification Identifiant
    connect(ihm, SIGNAL(identifiantDetecte(QString, QString)), this, SLOT(verifierAuthentificationIdentifiant(QString, QString)));

    // Authentification Utilisateur
    connect(this, SIGNAL(reponseDemandeDeConnexion(bool,QString)), ihm, SLOT(traiterDemandeDeConnexion(bool,QString)));

    // Article
    connect(communication, SIGNAL(envoieTramePoids(QString)), this, SLOT(traiterTramePoids(QString)));
    connect(ihm, SIGNAL(rechercheArticle(QString)), this, SLOT(rechercherArticle(QString)));
    connect(this, SIGNAL(articlesTrouves(QVector<QStringList>)), ihm, SLOT(mettreAJourListeArticles(QVector<QStringList>)));
    connect(ihm, SIGNAL(articleSelectionne(QString)), this, SLOT(selectionnerArticle(QString)));
    connect(this, SIGNAL(donneesArticleSelectionne(QStringList)), ihm, SLOT(afficherDonneesArticleSelectionne(QStringList)));
    connect(this, SIGNAL(donneesArticleSelectionne(QVector<QStringList>)), ihm, SLOT(afficherDonneesArticleSelectionne(QVector<QStringList>)));
    connect(this, SIGNAL(erreurDepassementQuantite()), ihm, SLOT(afficherErreurDepassementQuantite()));
}

void Supervision::rechercherArticle(QString recherche)
{
    QString requete = "SELECT Stock.NumeroCasier, Article.idType, Article.Nom, Stock.Quantite, Stock.Disponible, Article.Designation FROM Stock INNER JOIN Article ON Stock.idArticle = Article.idArticle WHERE Article.Nom LIKE '%" + recherche + "%' OR Article.Code LIKE '%" + recherche + "%' OR Article.Designation LIKE '%" + recherche + "%' ORDER BY Stock.NumeroCasier ASC";

    QVector<QStringList> listeArticlesTrouves;
    bdd->recuperer(requete, listeArticlesTrouves);

    emit articlesTrouves(listeArticlesTrouves);
}

void Supervision::selectionnerArticle(QString nomArticle)
{
    #ifdef DEBUG_SUPERVISION
        qDebug() << Q_FUNC_INFO << "Nom article" << nomArticle;
    #endif

    Article *article = new Article(this);
    QVector<QStringList> donneesArticle;
    QStringList donnees;

    unsigned int nombreCasiers = Article::recupererNombreCasiersPourNomArticle(nomArticle);    
    #ifdef DEBUG_SUPERVISION
        qDebug() << Q_FUNC_INFO << "nombreCasiers" << nombreCasiers;
    #endif

    if(nombreCasiers > 1)
    {
        QVector<QString> numeroDesCasiers;

        numeroDesCasiers = Article::recupererNumeroCasierPourNomArticle(nomArticle);

        for(int i = 0; i < numeroDesCasiers.size(); i++)
        {
            article->recupererDonneesArticleParNumeroCasier(numeroDesCasiers[i]);
            ajouterDonneesArticle(article, donneesArticle, donnees);
        }

        if(!donneesArticle.isEmpty())
        {
            emit donneesArticleSelectionne(donneesArticle);
        }
    }
    else
    {
        article->recupererDonneesArticleParNom(nomArticle);
        ajouterDonneesArticle(article, donneesArticle, donnees);

        if(!donneesArticle.isEmpty())
        {
            emit donneesArticleSelectionne(donneesArticle.at(0));
        }
    }
}

void Supervision::traiterTramePoids(QString trame)
{
    #ifdef DEBUG_SUPERVISION
        qDebug() << Q_FUNC_INFO << trame;
    #endif    

    QString numCasier = extraireNumeroCasier(trame);

    Article *article = new Article(this);
    if(article->recupererDonneesArticleParNumeroCasier(numCasier))
    {
        #ifdef DEBUG_SUPERVISION
            qDebug() << Q_FUNC_INFO << "Article" << article->get(TABLE_ARTICLE_NOM_ARTICLE) << article->get(TABLE_ARTICLE_QUANTITE) << article->get(TABLE_ARTICLE_DISPONIBLE);
        #endif

        int nombreArticle = compter(article->get(TABLE_ARTICLE_POIDS), extrairePoids(trame), article->get(TABLE_ARTICLE_TARE));

        QString strArticleQuantite = article->get(TABLE_ARTICLE_QUANTITE);

        int articleQuantite = strArticleQuantite.toInt();

        if(nombreArticle > articleQuantite)
        {
            emit erreurDepassementQuantite();
        }
        else
        {
            article->mettreAJourQuantite(QString::number(nombreArticle));
        }
    }
    else
    {
        #ifdef DEBUG_SUPERVISION
            qDebug() << Q_FUNC_INFO << "Article introuvable !";
        #endif
    }
}

QString Supervision::extrairePoids(QString trame)
{
    QString poids = trame.section(';',3,3);

    #ifdef DEBUG_SUPERVISION
        qDebug() << Q_FUNC_INFO << "poids:" << poids;
    #endif

    return poids;
}

QString Supervision::extraireNumeroCasier(QString trame)
{
    QString numCasier = trame.section(';',2,2);

    #ifdef DEBUG_SUPERVISION
        qDebug() << Q_FUNC_INFO << "numCasier:" << numCasier;
    #endif

    return numCasier;
}

int Supervision::compter(QString poidsArticle, QString poidsTotal, QString tare)
{
    //arrondie et conversion en entier
    int intPoidsArticle = arrondir(poidsArticle);

    #ifdef DEBUG_SUPERVISION
        qDebug() << Q_FUNC_INFO << "intPoidsArticle:" << intPoidsArticle;
    #endif

    int intPoidsTotal = arrondir(poidsTotal);

    #ifdef DEBUG_SUPERVISION
        qDebug() << Q_FUNC_INFO << "intPoidsTotal:" << intPoidsTotal;
    #endif

    int intTare = arrondir(tare);

    #ifdef DEBUG_SUPERVISION
        qDebug() << Q_FUNC_INFO << "tare:" << intTare;
    #endif

    //comptage du nombre d'articles

    double doubleNombreArticle = (intPoidsTotal - intTare) / intPoidsArticle;
    QString strNombreArticle = QString::number(doubleNombreArticle, 'f', PRECISION);
    int nombreArticle = strNombreArticle.toInt();

    #ifdef DEBUG_SUPERVISION
        qDebug() << Q_FUNC_INFO << "nombreArticle:" << nombreArticle;
    #endif

    return nombreArticle;
}

int Supervision::arrondir(QString arrondire)
{
    double doubleArrondire = arrondire.toDouble();
    QString strArrondire = QString::number(doubleArrondire, 'f', PRECISION);
    int doubleArrondie = strArrondire.toInt();

    return doubleArrondie;
}

void Supervision::ajouterDonneesArticle(Article *article, QVector<QStringList> &donneesArticle, QStringList &donnees)
{
    donnees << article->get(TABLE_ARTICLE_QUANTITE);
    donnees << article->get(TABLE_ARTICLE_DISPONIBLE);
    donnees << article->get(TABLE_ARTICLE_NUMERO_CASIER);

    donneesArticle.push_back(donnees);
    donnees.clear();
}