entite.cpp

#include "entite.h"
#include <QFontMetrics>
#include <QAction>
#include <QGraphicsWidget>
#include<QGraphicsSceneContextMenuEvent>
#include <QGraphicsItem>
#include <QMenu>
#include <QDebug>
#include "field.h"
#include <QInputDialog>
#include "mainwindow.h"
#include "lien.h"
#include "association.h"


class Property;
class Lien;
class Association;

Entite::~Entite()
{
    qDebug()<<"Entite::~Entite()";
    if(this->rectTitle!=NULL)
    {
        delete this->rectTitle;
        rectTitle=NULL;
    }
    else
    {
        delete this->title;
        this->title=NULL;
    }

    //On n'efface pas les champs parce qu'ils ont pour parent l'entité et qu'ils sont donc supprimés automatiquement

    //effacement des liens qui partent ou arrivent à l'objet
    foreach(Lien* leLien,vectLiens)
    {
        maman->supprimerLien(leLien);
    }
}

void Entite::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
    QGraphicsRectItem::paint(painter,option,0);
    foreach(Lien* unLien, vectLiens)
    {
        unLien->QGraphicsItemGroup::update(unLien->boundingRect());
    }
}

void Entite::redraw()
{
    //calcul de la largeur et de la hauteur;
    long hauteur=20+QFontMetrics(title->font()).height()*vecteurChamps.size()*1.5;
    long largeur=QFontMetrics(title->font()).width(nomTableTronque())+20;
    for(int noChamp=0;noChamp<vecteurChamps.count();noChamp++)
    {
        long largeurDuChamp=QFontMetrics(title->font()).width(vecteurChamps[noChamp]->getNomComplet())+20;
        if (largeurDuChamp>largeur) largeur=largeurDuChamp;
    }
    //le gros rectangle jaune de l'entité
    setRect(0,0,largeur,hauteur);
    setBrush(QColor("#FFFFA4"));//jaune
    //le titre
    if(!association)
    {
        rectTitle->setRect(0,0,largeur,QFontMetrics(title->font()).height()+10);
        rectTitle->setBrush(QColor("#D6FF9A"));//vert
        rectTitle->setPos(0,0);
    }
    //le texte du titre
    title->setPos(0,0);//par rapport à son parent
    title->setTextWidth(boundingRect().width());
    title->setHtml("<center>"+nomTableTronque()+"</center>");

    //les champs
    int ordonnee=0;
    if(!association)ordonnee=rectTitle->rect().height();
    else ordonnee=title->boundingRect().height();
    for(int noChamp=0;noChamp<vecteurChamps.count();noChamp++)
    {
        vecteurChamps[noChamp]->setPos(10,ordonnee);
        QString texte;
        if(noChamp==0 && !association)
        {
            texte="<b><u>"+vecteurChamps[noChamp]->getNomComplet()+"</u></b>";
        }
        else texte=vecteurChamps[noChamp]->getNomComplet();

            vecteurChamps[noChamp]->setHtml(texte);
        ordonnee+=vecteurChamps[noChamp]->boundingRect().height();
    }

}
int Entite::noLien(Entite* lAutre, Lien* unLien)
{
    int resultat=0;
    foreach (Lien* leLien, vectLiens)
    {
        if((leLien->t1==this && leLien->t2==lAutre) ||(leLien->t2==this && leLien->t1==lAutre)){
            resultat++;
            if(leLien==unLien)
                return resultat;
        }
    }
    return resultat;
}
int Entite::nbLien(Entite* lAutre)
{
    int resultat=0;
    foreach (Lien* leLien, vectLiens)
    {
        if((leLien->t1==this && leLien->t2==lAutre) ||(leLien->t2==this && leLien->t1==lAutre)){
            resultat++;
        }
    }
    return resultat;
}
Entite::Entite(MainWindow* mum,QString nom,qreal x,qreal y, QGraphicsItem* parent, QCustomGraphicsScene * laScene,QStringList listeDesChamps,bool isAssoc)
        :maman(mum),QGraphicsRectItem(x,y,200,200,parent), QListWidgetItem(nom)

{
qDebug()<<"constructeur de table";
association=isAssoc;
    nomEntite=nom;
    //le titre
    if(!association)
    {
        rectTitle=new QGraphicsRectItem(this);
        title=new QGraphicsTextItem(rectTitle);
    }
    else
    {
        title=new QGraphicsTextItem(this);
    }
    //police du titre
    title->setFont(QFont("Verdana",10,QFont::Bold,false));
    //déterminons la largeur de la table ainsi que sa hauteur:
    long hauteur=20;//marge haut + basse
    hauteur+=QFontMetrics(title->font()).height();
    int marge=20;
    long largeurMaxi=QFontMetrics(title->font()).width(nomTableTronque()+marge);
    for(int noChamp=0;noChamp<listeDesChamps.count();noChamp++)
    {
        long largeurDuChamp=QFontMetrics(title->font()).width(listeDesChamps[noChamp]+nomEntite);
        hauteur+=QFontMetrics(title->font()).height();
        if (largeurDuChamp>largeurMaxi) largeurMaxi=largeurDuChamp;
    }

    //construction du QGraphicsRectItem
    setRect(x,y,largeurMaxi+10,200);


    //création du titre
    setBrush(QColor("#FFFF00"));//jaune
    title->setPos(0,0);//par rapport à son parent
    title->setTextWidth(boundingRect().width());
    title->setHtml("<center>"+nomTableTronque()+"</center>");

    //stockage de quelques infos
    //c'est une table
    title->setData(32,"Table");
    title->setData(34,qVariantFromValue((qlonglong)this));
    //on stocke son nom
    title->setData(33,nomEntite);
    QGraphicsItem::setData(32,"Table");
    QGraphicsItem::setData(33,nomEntite);
    QGraphicsItem::setData(34,qVariantFromValue((qlonglong)this));
    long ordonne=title->boundingRect().height();

    this->setRect(0,0,largeurMaxi+10,ordonne+10);
    //création des champs dans la table
    for(int noChamp=0;noChamp<listeDesChamps.count();noChamp++)
    {
        QString tipe="VARCHAR";
        QString taille="25";
        QString role="";
        if(noChamp==0)
        {
            tipe="INTEGER";
            taille="";
            role="Identifiant de "+nomEntite;
        }


        vecteurChamps.push_back(new Property(maman,false,laScene,listeDesChamps[noChamp]+nomEntite,tipe,role,taille,this));
        vecteurChamps[noChamp]->setPos(10,ordonne);
        //sa table c'est moi
        vecteurChamps[noChamp]->lEntite=this;
        //vecteurChamps[noChamp]->setFlag(QGraphicsItem::ItemIsSelectable,true);
        vecteurChamps[noChamp]->setData(32,"Field");
        vecteurChamps[noChamp]->setData(33,nom+"."+listeDesChamps[noChamp]);
        ordonne+=vecteurChamps[noChamp]->boundingRect().height();

    }
    setRect(0,0,largeurMaxi+20,ordonne);
    setAcceptDrops(false);

}



 void Entite::contextMenuEvent(QGraphicsSceneMouseEvent *event)
 {
     //ce qui se passe lorsque le menu contextuel de la table est appelé
     qDebug()<<"void Entite::contextMenuEvent(QGraphicsSceneMouseEvent *event)";
     QMenu menu(QObject::tr("Object Menu"));
     //ajout du titre

     QAction* titre=new QAction(menu.title(),this->maman);
    titre->setDisabled(true);
    menu.addAction(titre);

    titre->setFont(QFont("verdana",9,3,true));


     //si je n'était pas sélectionnée, je le deviens
     QGraphicsItem::setSelected(true);
     //selection de l'objet
     maman->selectionne(this);
     //création des actions du menu
     QAction *removeAction = menu.addAction(QObject::tr("&Remove Object"));
     QAction *addPropertyAction = menu.addAction(QObject::tr("&Add property"));
     //exécution du menu
     QAction * actionChoisie=menu.exec(event->screenPos());
     if(actionChoisie==removeAction)
     {
         maman->tableSupprimer(this);
     }
     else
     {
         if(actionChoisie==addPropertyAction)
         {
             maman->tableAjouterChamp(this);
         }
     }

 }


QVector<Entite*> Entite::renvoieEntiteMeres()
{
    QVector<Entite*> resultat;
    foreach (Lien* leLien, vectLiens)
    {
        if (QObject::tr("Leak Relation")==leLien->typeDeJointure)
        {
            if(leLien->t1==this)
            {
                resultat.push_back(leLien->t2);
            }
        }
    }
    return resultat;
}
QStringList Entite::renvoieChampsEtrangers()
{
    QStringList resultat;
    foreach (Lien* leLien, vectLiens)
    {
        if (QObject::tr("Cif")==leLien->typeDeJointure or QObject::tr("Df")==leLien->typeDeJointure or QObject::tr("Leak Relation")==leLien->typeDeJointure)
        {
            if(leLien->t1==this)
            {
                if(leLien->role!=NULL)
                                    resultat<<leLien->texteDuRole;
                                else
                resultat<<leLien->t2->getPrimaryKeyAsFields();
            }
        }
        if (QObject::tr("Leg")==leLien->typeDeJointure)
        {
            if(leLien->t2==this)
            {   if(leLien->role!=NULL)
                    resultat<<leLien->texteDuRole;
                else
                    resultat<<leLien->t1->getPrimaryKeyAsFields();
            }
        }
    }
    return resultat;
}
QStringList Entite::renvoieClefsEtrangeres(bool constraintInsideTable)
{

    QStringList resultat;
    QString debut="";
    if(!constraintInsideTable)debut="ALTER TABLE "+nomEntite+" ADD ";
    QString fin="";
    if(!constraintInsideTable)fin=";";

    foreach (Lien* leLien, vectLiens)
    {
        if (QObject::tr("Cif")==leLien->typeDeJointure or QObject::tr("Df")==leLien->typeDeJointure or QObject::tr("Leak Relation")==leLien->typeDeJointure)
        {
            if(leLien->t1==this)
            {
                resultat<<debut+leLien->t2->getkeyAsForeignKey(leLien->texteDuRole)+fin;
            }
        }
        if (QObject::tr("Leg")==leLien->typeDeJointure)
        {
            if(leLien->t2==this)
            {
                resultat<<debut+leLien->t1->getkeyAsForeignKey(leLien->texteDuRole)+fin;
            }
        }
    }
    return resultat;
}
bool Entite::canBeWriten(QVector <Entite*>vectEntitesGeneres)
{
    bool resultat=true;
    foreach (Lien* leLien, vectLiens)
    {
        if (QObject::tr("Cif")==leLien->typeDeJointure or QObject::tr("Df")==leLien->typeDeJointure or QObject::tr("Leak Relation")==leLien->typeDeJointure)
        {
            if(leLien->t1==this)
            {
                resultat=resultat && (vectEntitesGeneres.contains(leLien->t2)||leLien->t1==leLien->t2);
            }
        }
        if (QObject::tr("Leg")==leLien->typeDeJointure)
        {
            if(leLien->t2==this)
            {
                //resultat<<leLien->t1->getkeyAsForeignKey();
                resultat=resultat && vectEntitesGeneres.contains(leLien->t1);
            }
        }
    }
    return resultat;
}

bool Entite::isEntiteFaible()
{
    return(renvoieEntiteMeres().size()>0);
}

QString Entite::getPrimaryKey()
{

    if(!association)
    {
        if(!isEntiteFaible())//entité
        {
            return vecteurChamps[0]->nom;
        }
        else//entité faible
        {
            //obtention des tables mères
            QVector<Entite*> entitesMeres=renvoieEntiteMeres();
            QStringList listeDesNoms;
            foreach (Entite* lEntite, entitesMeres)
            {
                listeDesNoms<<lEntite->getPrimaryKey();
            }
            listeDesNoms<<vecteurChamps[0]->nom;
            return listeDesNoms.join(',');
        }
    }
    else//association
    {
        //prendre l'ensemble des clefs de chaque patte de l'assoc
        QVector<Entite*> vectEnt=((Association*)this)->vectEntitesAssociees();
        QStringList slPK;
        foreach (Entite* lEntite, vectEnt) {
            slPK<<lEntite->getPrimaryKey();
        }
        return slPK.join(',');
    }
}


QString Entite::getPrimaryKeyAsFields(bool references)
{
    if(!association)
    {
        if(!isEntiteFaible())//je suis une entité
        {
            QString laChaine=this->vecteurChamps[0]->nom+" "+this->vecteurChamps[0]->sonType;
            QString taille=this->vecteurChamps[0]->taille;
            if(!taille.isEmpty()) laChaine+="("+taille+")";

            return(laChaine);
        }
        else//c'est une entite faible
        {
            //obtention des tables mères
            QVector<Entite*> entitesMeres=renvoieEntiteMeres();
            QStringList listeDesNoms;
            foreach (Entite* lEntite, entitesMeres)
            {
                QString laChaine=lEntite->getPrimaryKeyAsFields();
                listeDesNoms<<laChaine;
            }
            return listeDesNoms.join(',')+','+vecteurChamps[0]->nom;
        }
    }
    else//c'est une association
    {
        //prendre l'ensemble des clefs de chaque patte de l'assoc
        QVector<Entite*> vectEnt=((Association*)this)->vectEntitesAssociees();
        QStringList slPK;
        foreach (Entite* lEntite, vectEnt) {
            slPK<<lEntite->getPrimaryKeyAsFields(false);
        }
        return slPK.join(',');
    }
}
QString Entite::getkeyAsForeignKey(QString role)
{

    QString motReserve="#ad2bee";
    QString typeChamp="#87711d";
    QString nomTable="#29a329";
    QString nomChamp="#39b339";
    QString tailleChamp="#97812d";
    QString laChaine="<font color=\""+motReserve+"\"> foreign key </font> (";
    if(role.isEmpty())
    {
        laChaine+=getPrimaryKey();
    }
    else
    {
        laChaine+=role;
    }
    laChaine+=+") <font color=\""+motReserve+"\">references</font> "+this->nomEntite+"("+getPrimaryKey()+")";
    return(laChaine);


}
QString Entite::toSql(bool withoutFK)
{
    qDebug()<<"QString Entite::toSql()";
    QStringList defs;
    QString resultat;
    //le début de  la requête
    QString motReserve="#ad2bee";
    QString typeChamp="#87711d";
    QString nomTable="#29a329";
    QString nomChamp="#39b339";
    QString tailleChamp="#97812d";

    resultat="<font color=\""+motReserve+"\">CREATE TABLE</font> <font color=\""+nomTable+"\">`"+nomTableTronque()+"`</font>(";
    //demander à chaque champ de l'entité de s'écrire ici
    QStringList defChamp;
    foreach (Property* leChamp, vecteurChamps) {
        defs<<leChamp->toSql();
    }

    //les champs étrangers
    ;
    defs.append(renvoieChampsEtrangers());

    //les clés étrangères

    if(!withoutFK) defs.append(renvoieClefsEtrangeres());

    //la clef primaire
    defs.append("<font color=\""+motReserve+"\"><b>primary key</b></font>(<u>"+getPrimaryKey()+"</u>)");
    //ajout des définitions
    resultat+=defs.join(',');
    //la toute fin de la requête
    resultat+=");";
    return resultat;
}