void ViewMenuListeDesTaches::enregistrementDansLaTableTache()
{
QString insertDansTache ("INSERT INTO tache (Poids_Tache,Depart_X,Depart_Y,Arrive_X, Arrive_Y, ID_Liste_Taches, ID_Robot) VALUES (");
bool firstVirgule = true;
if(this->listeTache->getListeDesTaches()->size()>0){
for(int i = 0;i<listeTache->getListeDesTaches()->size();i++){
if(!firstVirgule){
insertDansTache.append(" ),( ");
}
Tache tacheTemp = *listeTache->getListeDesTaches()->at(i);
insertDansTache.append("'");
insertDansTache.append(QString::number(tacheTemp.getPoids()));
insertDansTache.append("',");
insertDansTache.append(QString::number(tacheTemp.depart->getX()));
insertDansTache.append( ",");
insertDansTache.append(QString::number(tacheTemp.depart->getY()));
insertDansTache .append(",");
insertDansTache.append(QString::number(tacheTemp.arrivee->getX()));
insertDansTache .append( ",");
insertDansTache.append(QString::number(tacheTemp.arrivee->getY()));
insertDansTache .append(",");
insertDansTache.append(QString::number(this->listeTache->IDListeTache));
insertDansTache .append(",");
insertDansTache.append(QString::number(tacheTemp.idRobot));
firstVirgule = false;
}
insertDansTache.append("); ");
GestionDB * db = GestionDB::getInstance();
db->Requete(insertDansTache);
}
}
QVector<Tache*> ProjetManager::getTachesFromProjet(Projet* p)
{
QVector<Tache*> v;
for (QVector<Tache*>::const_iterator it = this->liste.cbegin(); it != this->liste.cend(); ++it)
{
if (dynamic_cast<Projet*>(*it) == 0)
{
Tache* t = *it;
if(t->getProjet() == p)
v.push_back(*it);
}
}
return v;
}
void TacheManager::setDatesDisponibiliteEcheance(Tache& t, const QDate& disp, const QDate& e)
{
if (e<disp)
throw CalendarException("erreur Tâche : date echéance < date disponibilité");
const list<Tache*> l = this->getTaches();
list<Tache*>::const_iterator it;
for( it = l.begin() ; it != l.end() ; ++it )
{
if( (*it)->estPredecesseur(t) )
{
if( (*it)->getDateDisponibilite() > disp )
throw CalendarException( "Le successeur "+(*it)->getTitre()+" possede une date de dispo supérieure" );
if( (*it)->getDateEcheance() < e )
throw CalendarException( "Le successeur "+(*it)->getTitre()+" possede une date d'échéance inférieure" );
}
TacheComposite* tc = dynamic_cast<TacheComposite*>(*it);
if( tc && tc->estSousTache(t) )
{
if( (*it)->getDateDisponibilite() > disp )
throw CalendarException( "La sur-tache "+tc->getTitre()+" possede une date de dispo supérieure" );
if( (*it)->getDateEcheance() < e )
throw CalendarException( "Le successeur "+tc->getTitre()+" possede une date d'échéance inférieure" );
}
}
t.setDatesDisponibiliteEcheance(disp, e);
}
FenetreProgrammerTache::FenetreProgrammerTache(Tache& t): tache(t){
titreLabel = new QLabel("Programmer une tache");
nom = new QLabel(this);
nom->setText(QVariant(t.get_titre()).toString());
duree=new QLabel();
duree->setText(QVariant(t.get_duree().getDureeEnMinutes()).toString());
date= new QLabel("Date: ");
horaire= new QLabel("Horaire: (h-m)");
ProgDate= new QDateEdit();
ProgDate->setDate(QDate::currentDate());
ProgHh= new QSpinBox();
ProgHm = new QSpinBox();
progDuree= new QLabel();
progDuree->setText("Durée de la programmation h/m: ");
Durh=new QSpinBox();
Durm=new QSpinBox();
coucheV1= new QVBoxLayout();
coucheV1->addWidget(titreLabel);
coucheV1->addWidget(nom);
coucheV1->addWidget(duree);
coucheH1= new QHBoxLayout();
coucheH1->addWidget(date);
coucheH1->addWidget(ProgDate);
coucheH2= new QHBoxLayout();
coucheH2->addWidget(horaire);
coucheH2->addWidget(ProgHh);
coucheH2->addWidget(ProgHm);
coucheH3=new QHBoxLayout();
coucheH3->addWidget(progDuree);
coucheH3->addWidget(Durh);
coucheH3->addWidget(Durm);
Enregistrer=new QPushButton("Enregistrer");
coucheV1->addLayout(coucheH1);
coucheV1->addLayout(coucheH2);
coucheV1->addLayout(coucheH3);
coucheV1->addWidget(Enregistrer);
setLayout(coucheV1);
QObject::connect(Enregistrer,SIGNAL(clicked()),this,SLOT(enregistrer()));
}
QVector<Tache*> ProjetManager::getPossiblePredecesseurs(Projet* p, Tache *succ)
{
DependanceManager *dm = DependanceManager::getInstance();
QVector<Tache*> v;
for (QVector<Tache*>::const_iterator it = this->liste.cbegin(); it != this->liste.cend(); ++it)
{
if (dynamic_cast<Projet*>(*it) == 0)
{
Tache* t = *it;
if(t->getProjet() == p
&& t->getDebTot() < succ->getDebTot()
&& t->getFinTard() < succ->getFinTard()
&& dm->get(*t, *succ) == 0
&& dm->get(*succ, *t) == 0)
v.push_back(*it);
}
}
return v;
}
void MainWindow::attachChildTask(QTreeWidgetItem* item, Tache* t) const {
for (TacheManager::iterator it = tm->begin(); it != tm->end(); ++it) {
QTreeWidgetItem* tache_item = new QTreeWidgetItem();
Tache* tmp = *it;
if (!tmp->getTache_conteneur() || tmp->getTache_conteneur()->getId() != t->getId()) {
delete tache_item;
continue;
}
tache_item->setText(1,tmp->getTitre());
tache_item->setText(2,tmp->getDateDisponibilite().toString());
if (TacheComposite* tc = dynamic_cast<TacheComposite*>(*it)) {
tache_item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsEditable);
tache_item->setText(0,"Tâche composite");
} else {
TacheUnitaire* tu = dynamic_cast<TacheUnitaire*>(*it);
tache_item->setText(5,Tache::etatToString(tu->getEtat()).replace("_"," "));
if (TacheUnitairePreemptable* tp = dynamic_cast<TacheUnitairePreemptable*>(*it))
tache_item->setText(0,"Tâche unitaire préemptable");
else
tache_item->setText(0,"Tâche unitaire");
tache_item->setText(3,QString::number((dynamic_cast<TacheUnitaire*>(*it))->getDuree().getDureeEnMinutes())+"min");
tache_item->setFlags(Qt::ItemNeverHasChildren |Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsEditable);
}
tache_item->setText(4,tmp->getEcheance().toString());
item->addChild(tache_item);
item->setExpanded(true);
attachChildTask(tache_item, tmp);
}
}
void EmploiDuTemps::afficheInfos(int row, int column){
if(ui->tableWidget->item(row, column)){ //si la case contient une programmation
try {
ui->stackedWidget->setHidden(false);
QTableWidgetItem* item = ui->tableWidget->item(row, column);
if(item->background()== QBrush(QColor(191,117,255))){
//l'item est un evt
ui->stackedWidget->setCurrentIndex(0);
const Programmation* evt = ProgrammationManager::getInstance().trouverEvenement(item->whatsThis());
ui->labelDescr->setText(evt->getEvenement()->getDescription());
ui->labelLieu->setText(evt->getEvenement()->getLieu());
ui->labelNom->setText(evt->getEvenement()->getNom());
ui->labelDate->setText(evt->getDate().toString(Qt::SystemLocaleShortDate));
ui->labelDuree->setText(evt->getDuree().stringDuree());
ui->labelType->setText(evt->getEvenement()->getType());
ui->labelHor->setText(evt->getTime().toString("HH:mm"));
}
else if (item->background()==QBrush(QColor(85,255,127))){
//l'item est une tache
ui->stackedWidget->setCurrentIndex(1);
Tache* t = ProjetManager::getInstance().trouverTache(item->whatsThis());
ui->labelId->setText(t->getId());
ui->labelTitre_2->setText(t->getTitre());
ui->labelProjet->setText(t->getProjet()->getNom());
ui->labelDate_2->setText(ui->tableWidget->horizontalHeaderItem(column)->text());
ui->labelHor_2->setText(item->text().section(" ",0,0));
ui->labelDuree_2->setText("\n\n"+item->text().section("durée : ",1,1));
}
}catch(CalendarException e){
QMessageBox::warning(this, "Erreur", e.getInfo());
}
}
else //si la case est vide
ui->stackedWidget->setHidden(true);
}
void Tache::ajouterTachePrecedente(Tache & tachePrecedente, const std::string& cheminementPrecedent, const std::string& cheminementSuivant){
if(trouverTachePrecedente(cheminementPrecedent)!=0){
throw TacheException("Erreur : la tâche " + tachePrecedente.getTitre() + " précède déjà la tâche "+ this->getTitre()+".");
}
if(tachePrecedente.trouverTachePrecedente(cheminementSuivant)!=0){
throw TacheException("Erreur : la tâche " + tachePrecedente.getTitre() + " a pour tâche precedente la tâche "+ this->getTitre()+".");
}
if(cheminementPrecedent.compare(cheminementSuivant)==0){
throw TacheException("Erreur : la tache "+cheminementSuivant+" ne peut pas se précéder elle meme.");
}
std::size_t found = cheminementPrecedent.find(cheminementSuivant);
if (found!=std::string::npos){
throw TacheException("Erreur : la tache mère "+cheminementSuivant+ " ne peut pas débuter après la fin de sa tache descendante " + cheminementPrecedent+".");
}
found = cheminementSuivant.find(cheminementPrecedent);
if (found!=std::string::npos){
throw TacheException("Erreur : la tache fille "+cheminementSuivant+" ne peut pas débuter après la fin de sa tache ascendante " + cheminementPrecedent+".");
}
if( ((this->getDateFin()-tachePrecedente.getDateDebut())*24*60+(this->getHoraireFin()-tachePrecedente.getHoraireDebut()))
-int(tachePrecedente.getDuree().getDureeEnMinutes())< int(this->getDuree().getDureeEnMinutes())){
throw TacheException("Erreur : la tâche " + this->getTitre() + " ne sera pas programmable.");
}
tachesPrecedentes.insert(std::pair<std::string, Tache*>(cheminementPrecedent, &tachePrecedente)); // ajout de la contrainte de précédence si cela est cohérent
}
void MainWindow::displayProjetsAndTasks() const {
this->projets->clear();
qDebug()<<"Mise à jour des taches et projets de la vue de la fenêtre principale";
for (ProjetManager::iterator it = pm->begin(); it != pm->end(); ++it ){
QTreeWidgetItem* item = new QTreeWidgetItem();
item->setText(0,"Projet");
item->setText(1,(*it)->getNom());
item->setText(2,(*it)->getDispo().toString());
item->setText(4,(*it)->getEcheance().toString());
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsEditable);
this->projets->addTopLevelItem(item);
for (TacheManager::iterator itt = tm->begin(); itt != tm->end(); ++itt) {
QTreeWidgetItem* tache_item = new QTreeWidgetItem();
Tache* t = *itt;
if (!t->getProjet_conteneur() ||t->getProjet_conteneur()->getNom() != (*it)->getNom()) {
delete tache_item;
continue;
}
tache_item->setText(1,t->getTitre());
tache_item->setText(2,t->getDateDisponibilite().toString());
tache_item->setText(4,t->getEcheance().toString());
if (TacheComposite* tc = dynamic_cast<TacheComposite*>(*itt)) {
tache_item->setText(0,"Tâche composite");
tache_item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsEditable);
} else {
tache_item->setText(5,Tache::etatToString(dynamic_cast<TacheUnitaire*>(*itt)->getEtat()).replace("_"," "));
if (TacheUnitairePreemptable* tp = dynamic_cast<TacheUnitairePreemptable*>(*itt))
tache_item->setText(0,"Tâche unitaire préemptable");
else
tache_item->setText(0,"Tâche unitaire");
tache_item->setText(3,QString::number((dynamic_cast<TacheUnitaire*>(*itt))->getDuree().getDureeEnMinutes())+"min");
tache_item->setFlags(Qt::ItemNeverHasChildren | Qt::ItemIsSelectable |Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsEditable);
}
item->addChild(tache_item);
item->setExpanded(true);
attachChildTask(tache_item, *itt);
}
}
}
void ProjetManager::supprimerTache(const QString &id)
{
Tache* t = ProjetManager::getInstance().getTache(id);
Projet* p = t->getProjet();
p->supprimerTache(id);
}
void MainWindow::onTreeWidgetItemDoubleClicked(QTreeWidgetItem * item, int column)
{
if (column==1) { // nom
QString id = item->text(1);
edittitle* edittitre = new edittitle(this);
edittitre->setTitle(id);
if (edittitre->exec() == QDialog::Accepted) {
QString newTitre = edittitre->getTitle();
if(item->text(0)=="Projet"){
Projet* tmp = pm->trouverProjet(id);
tmp->setNom(newTitre);
}
else{
Tache* tmp = tm->trouverTache(id);
tmp->setTitre(newTitre);
}
}
delete edittitre;
}
if (column==2) { // date dispo
QString id = item->text(1);
popupdispo = new datedispo(this);
popupdispo->setDate(QDate::fromString(item->text(2),Qt::TextDate));
if (popupdispo->exec() == QDialog::Accepted) {
QDate dateDisponible = popupdispo->getDate();
if(item->text(0)=="Projet"){
Projet* tmp = pm->trouverProjet(id);
tmp->setDispo(dateDisponible);
}
else{
Tache* tmp = tm->trouverTache(id);
tmp->setDateDisponibilite(dateDisponible);
}
}
delete popupdispo;
}
if (column==3 && item->text(0) != "Projet" && item->text(0) != "Tâche Composite") { //durée
QString id = item->text(1);
editduree* duree = new editduree(this);
if (duree->exec() == QDialog::Accepted) {
TIME::Duree dur = duree->getDuree();
TacheUnitaire* tmp = dynamic_cast<TacheUnitaire*>(tm->trouverTache(id));
try{tmp->setDuree(dur);}catch(TacheException e){
showError("Project Calendar", "\n Une tache unitaire non preemptable ne peut durer plus de 12h");
}
}
delete duree;
}
if (column==4 && item->text(0) != "Projet") { // echeance
QString id = item->text(1);
editecheance* echeance = new editecheance(this);
echeance->setDate(QDate::fromString(item->text(4),Qt::TextDate));
if (echeance->exec() == QDialog::Accepted) {
QDate dateEcheance = echeance->getDate();
Tache* tmp = tm->trouverTache(id);
tmp->setEcheance(dateEcheance);
}
delete echeance;
}
if (column==5 && (item->text(0) == "Tâche unitaire" || item->text(0) == "Tâche unitaire préemptable") && item->text(0) != "Tâche Composite") { // etat
QString id = item->text(1);
editetat* etat = new editetat(this);
TacheUnitaire* tmp = dynamic_cast<TacheUnitaire*>(tm->trouverTache(id));
etat->setTache(tmp);
if (etat->exec() == QDialog::Accepted) {
// do nothing
}
delete etat;
}
try {
tm->saveToDB();
pm->saveToDB();
}catch (ProjetManagerException e) {
showError("Project Calendar", e.getInfo()+"\nLes noms de projets doivent être uniques.");
tm->clearAll();
pm->clearAll();
pm->loadProjets();
tm->loadTaches();
em->clearAll();
em->loadEvents();
displayEvents(this->current_debut,this->current_fin);
}
catch (TacheManagerException e) {
showError("Project Calendar", e.getInfo()+"\nDeux tâches contenues dans la même tache ou le même projet ne peuvent avoir le même nom.");
tm->clearAll();
pm->clearAll();
pm->loadProjets();
tm->loadTaches();
em->clearAll();
em->loadEvents();
displayEvents(this->current_debut,this->current_fin);
}
displayProjetsAndTasks();
}
TacheEditeur::TacheEditeur(Tache& t, QWidget* parent):t(t), QWidget(parent){
vertical = new QVBoxLayout(this);
//couche1
couche1 = new QHBoxLayout;
id = new Qlabel("identificateur", this);
idLineEdit = new QLineEdit(this);
preemtive = new QCheckBox("preemptive",this);
couche1->addWidget(id);
couche1->addWidget(idLineEdit);
couche1->addWidget(preemtive);
//couche2
couche2 = new QHBoxLayout;
titre = new QLabel(this);
titreTextEdit = new QTextEdit(this);
couche2->addWidget(titre);
couche2->addWidget(titreTextEdit);
//couche3
couche3 = new QHBoxLayout;
dispo = new QLabel("Disponibilité", this);
echeance = new QLabel("Écheance", this);
duree = new QLabel("Durée", this);
dateDispo = new QDateEdit(this);
dateEcheance = new QDateEdit(this);
dureeH = new QSpinBox(this);
dureeM = new QSpinBox(this);
couche3->addWidget(dispo);
couche3->addWidget(dateDispo);
couche3->addWidget(echeance);
couche3->addWidget(dateEcheance);
couche3->addWidget(duree);
couche3->addWidget(dureeH);
couche3->addWidget(dureeM);
//couche4
couche4 = new QHBoxLayout;
annuler = new QPushButton("Annuler", this);
save = new QPushButton("Sauvegarder", this);
couche4->addWidget(annuler);
couche4->addWidget(save);
vertical->addItem(couche1);
vertical->addItem(couche2);
vertical->addItem(couche3);
vertical->addItem(couche4);
idLineEdit->setText(t.getId());
titreTextEdit->setText(t.getTitre());
dateDispo->setDate(t.getDateDisponibilite());
dateEcheance->setDate(t.getDateEcheance());
dureeH->setValue(t.getDuree().getHeure());
dureeM->setValue(t.getDuree().getMinute());
save->setEnabled(false);
QObject::connect(annuler,SIGNAL(clicked()),this,SLOT(close()));
QObject::connect(save,SIGNAL(clicked()),this, sauverTache());
QObject::connect(idLineEdit, SIGNAL(textChanged(QString)), this, SLOT(activerButton()));
QObject::connect(preemtive, SIGNAL(stateChanged()),save, SLOT(activerButton()));
QObject::connect(dateDipo, SIGNAL(dateChanged(QDate)), this, SLOT(verifierDate()));
}
