Exemple #1
0
bool Planning::addProgrammation(Programmation& prog) {
    Programmation *p = new Programmation(prog);

    if (programmations.empty()) {
        programmations.push_back(p);
    }
    else {
        Programmations::iterator it;
        for (it=programmations.begin(); it!=programmations.end(); ++it) {
            if (prog.getIntervalle().GetDebut() < (*it)->getIntervalle().GetDebut()) {
                break;
            }
        }

        // intersection
        if ((*it)->getIntervalle() && prog.getIntervalle()) {
            return false;
        }

        if (it != programmations.begin()) {

            --it;

            // intersection
            if ((*it)->getIntervalle() && prog.getIntervalle()) {
                return false;
            }
        }

        programmations.insert(it, p);

    }
}
Exemple #2
0
Programmation& Agenda::ajouterProg(Evenement* e, const QDateTime& d, const Horaire& h){
    if (trouverProgrammation(e)) throw AgendaException("erreur, tache deja existante dans le projet");
    if (e->getDate()<d && d<e->getEcheance()){
        if(e->getStatus()==false){
            //on vérifie qu'une tache precédente n'est pas programmée avant la tache qu'on programme
            if (e->withPrecedence()){ //Si l'événement a des precedences
                for(precedences_iterator it = e->begin_precedences() ; it != e->end_precedences() ; ++it){
                    if((*it)->getStatus()){//Si la précédence est programmée
                        //On vérifie la cohérence des dates
                        Programmation* prog = trouverProgrammation(*it);
                        if(prog->getDate() > d)
                            throw AgendaException("Impossible de programmer une tache avant de ses tâches précédentes");
                        else if (prog->getDate() == d && h < prog->getHoraire())
                            throw AgendaException("Impossible de programmer une tache avant de ses tâches précédentes");
                    }
                }
            }
            //L'événement n'est pas encore programmé et la date choisie est cohérente avec ses taches précédentes.
            //On peut créer la programmation
            Programmation* newt=new Programmation(d,h,e);
            e->setEstProg(true);
            addItem(newt);
            return *newt;
        }else throw AgendaException("l'evenement est déjà programmé");
    }else throw AgendaException("erreur les dates ne concordent pas");
};
QString Semaine::jourToString(int jour) const{
    QDate dateJour = getLundi().addDays(jour-1);
    list<Programmation*> lProgs;
    for(multimap<const QDate, Programmation*>::const_iterator it=evenements.begin(); it!=evenements.end(); ++it){
        if (it->first == dateJour)
            lProgs.push_back(it->second);
    }
    QString str;
    lProgs.sort(compareProg);
    Programmation * prog;
    for (list<Programmation*>::iterator it=lProgs.begin(); it != lProgs.end(); ++it){
        str += "[";
        prog = *it;
        str +=prog->toString();
        str += "] ";
    }
    //str =
    return str;
}
Exemple #4
0
Programmation::Programmation(const int id, const QDate &d, const QTime &dur, const QTime &h):id(id),date(d),duree(dur),horaire(h)
{
   ProgManager::Iterator it = ProgManager::getInstance()->getIterator();
   int jour = d.day();
   /*int debut = h.hour();
   int fin = debut + dur.hour();*/
   QTime debut=h;
   QTime fin;
   fin.setHMS(h.hour()+dur.hour(),h.minute()+dur.minute(),h.second()+dur.second());
   /*bool commencePendant=false;
   bool terminePendant=false;*/
   bool horaireinvalide=false;
   bool memeJour=false;
   while(it.courant() != ProgManager::getInstance()->end())
   {
       Programmation *p = it.valeur();
       /*int pH = p->getHoraire().hour();
       int pFin = pH + p->getDuree().hour();*/
       int pJour = it.valeur()->getDate().day();
     /*  commencePendant = (debut >= pH && debut <= pFin); //On autorise qu'un evenement se finisse à une heure h et qu'un autre commence tout de suite après
       terminePendant = (fin >= pH && fin <= pFin);*/
       QTime pDeb=p->getHoraire();
       QTime pFin;
       pFin.setHMS(p->getHoraire().hour()+p->getDuree().hour(),p->getHoraire().minute()+p->getDuree().minute(),p->getHoraire().second()+p->getDuree().second());
       /*commencePendant= (debut>=pDeb && debut<pFin);
       terminePendant= (fin>pDeb && fin<=pFin);*/
       horaireinvalide=(debut<=pDeb && fin>=pFin)
               || (debut<=pDeb && (fin<=pFin && fin>pDeb))
               || ((debut>=pDeb && debut<pFin) && fin>=pFin)
               || ((debut>=pDeb && debut<pFin) && (fin>=pDeb && fin<=pFin));
       memeJour = jour == pJour;
       if( memeJour && horaireinvalide)
               throw AgendaException("Une programmation occupe déjà une partie de cette plage horaire");
       it.next();
   }
}
void FenetreGraphique::miseAJourTableau(QStandardItemModel& model) //, QTableView& vue)
{
    //QMessageBox::information(this, "test", "fx de mise a jour");

    //qDebug() << model.rowCount();
    //model.clear();

    //pour tous les jours de la semaine correspondante dateReferenceAgenda    
    /*int jourDeLaSemaine = dateReferenceAgenda->dayOfWeek();
    QDate jourActu;
    for(unsigned int jour=1; jour<8; jour++)
    {
        jourActu = dateReferenceAgenda->addDays(jour-jourDeLaSemaine);
        itemCol0->setText(chaineJoursHeader(1, dateReferenceAgenda->addDays(1-jourDeLaSemaine).day(), dateReferenceAgenda->addDays(1-jourDeLaSemaine).month()));
        //Pour ttoutes les jours de cette semaine
            // On calcule la position row, column de chaque event->case correspondante
            //si la case existe deja, on ajoute (QStandardItem * QStandardItemModel::item(int row, int column = 0) const)
            //sinon nouvelle case et nouveau contenu
    }*/

    //Pour tous les projets
    /*for(int i =0; i< Manager<Projet>::getInstance().getSize(); ++i)
    {
        //for ( QVector<Tache*>::iterator it = projetActif->IteratorSousTachesBegin(); it != projetActif->IteratorSousTachesEnd(); ++it)
        //pour toutes les taches du projets
        for ( QVector<Tache*>::iterator it = Manager<Projet>::getInstance().getItem(i)->IteratorSousTachesBegin(); it != Manager<Projet>::getInstance().getItem(i)->IteratorSousTachesEnd(); ++it)
        {
            if((typeid(**it)==typeid(TacheUnitaire))||(typeid(**it)==typeid(TacheUnitairePreemptive)))
            {
                //on traite l'affichage pour cette tache
                afficherTacheDansAgenda(**it);
            }
            else if(typeid(**it)==typeid(TacheComposite))
            {
                recursiveAgenda(dynamic_cast<TacheComposite&>(**it));
            }
        }
    }*/
    //menuDeroulantProjets->addItem(Manager<Projet>::getInstance().getItem(i)->getId());

    int jourDeLaSemaine = dateReferenceAgenda->dayOfWeek();
    //Pour toutes les programmations nigaud
    for(unsigned int i=0; i<Manager<Programmation>::getInstance().getSize(); ++i)
    {
        Programmation* prog = Manager<Programmation>::getInstance().getItem(i);
        if((prog->getDate().date()>=dateReferenceAgenda->addDays(1-jourDeLaSemaine))&&(prog->getDate().date()<=dateReferenceAgenda->addDays(7-jourDeLaSemaine)))
        {
            //on est dans le cas ou la programmation se trouve dans la semaine active
            TIME::Duree heureDebut;
            TIME::Duree heureFin;
            //TIME::Duree heureTemp;
            int caseDeb=0;
            int caseFin=0;

            /*if(prog->getDate().time()<TIME::Duree(8, 0)) heureDebut=TIME::Duree(8,0);
            else heureDebut=prog->getDate().time();*/
/*
            heureFin=prog->getDate().time();
            heureFin=heureFin.addSecs(prog->getDuree().hour()*3600);
            heureFin=heureFin.addSecs(prog->getDuree().minute()*60);
*/
            /*if(heureTemp>TIME::Duree(, 0)) heureFin=TIME::Duree(19,0);
            else heureFin=heureTemp;*/
/*
            caseDeb=(heureDebut.hour()-7)*4+(heureDebut.minute()/15);
            caseFin=(heureFin.hour()-7)*4+(heureFin.minute()/15);
*/
            //model.setItem(caseDeb, jourDeLaSemaine-1, new QStandardItem(prog->getEvenement().getId()));
            vueAgenda->setSpan(caseDeb,prog->getDate().date().dayOfWeek(),caseFin-caseDeb,1);
            model.item(caseDeb, prog->getDate().date().dayOfWeek())->setBackground(QBrush(QColor(Qt::green)));
        }
    }


    /*model.setItem(0, 0, new QStandardItem("Origine"));
    model.item(0, 0)->setBackground(QBrush(QColor(Qt::green)));
    model.setItem(3, 2, new QStandardItem("Item"));
    model.setItem(3, 5, new QStandardItem("Item2"));*/
    //vue.setSpan(0,0,3,1);
   // vueAgenda->setSpan(0,0,3,3);
}
Exemple #6
0
void ExportXML::save(const QString& f){
    //file=f;
    ProjetManager& PM = ProjetManager::getInstance();
    Agenda& A = Agenda::getInstance();
    QFile newfile(f);
    if (!newfile.open(QIODevice::WriteOnly | QIODevice::Text))
        throw AgendaException(QString("erreur sauvegarde tâches : ouverture fichier xml"));
    QXmlStreamWriter stream(&newfile);
    stream.setAutoFormatting(true);
    stream.writeStartDocument();
    stream.writeStartElement("projectcalendar");
    //Liste des projets dans la balise <projets>
    stream.writeStartElement("projets");
    for(ProjetManager::projets_iterator it1 = PM.begin_projets() ; it1 != PM.end_projets() ; ++it1){
        //chaque projet est dans une balise <projet>
        stream.writeStartElement("projet");
        stream.writeTextElement("identificateur",(*it1)->getId());
        stream.writeTextElement("titre",(*it1)->getTitre());
        stream.writeTextElement("description",(*it1)->getDesc());
        stream.writeTextElement("disponibilite",(*it1)->getDispo().toString(Qt::ISODate));
        stream.writeTextElement("echeance",(*it1)->getEcheance().toString(Qt::ISODate));
        //Liste des taches du projet et de leurs programmations dans une balise <taches>
        stream.writeStartElement("taches");
        for(Projet::taches_iterator it2 = (*it1)->begin_taches() ; it2 != (*it1)->end_taches() ; ++it2){
            //Chaque tache dans une balise <tache>
            stream.writeStartElement("tache");
            //Met l'attribut preemptive à true si tache préemptable, false sinon
            if (typeid(**it2) == typeid(TachePreemptable))
                stream.writeAttribute("preemptive", "true");
            else
                stream.writeAttribute("preemptive", "false");
            //Met l'attribut composite à true si tache composite, false sinon
            if (typeid(**it2) == typeid(TacheComposite))
                stream.writeAttribute("composite", "true");
            else
                stream.writeAttribute("composite", "false");
            //Met l'attribut unitaire à true si tache unitaire, false sinon
            if (typeid(**it2) == typeid(TacheUnitaire))
                stream.writeAttribute("unitaire", "true");
            else
                stream.writeAttribute("unitaire", "false");

            stream.writeTextElement("identificateur",(*it2)->getId());
            stream.writeTextElement("titre",(*it2)->getTitre());
            stream.writeTextElement("disponibilite",(*it2)->getDate().toString(Qt::ISODate));
            stream.writeTextElement("echeance",(*it2)->getEcheance().toString(Qt::ISODate));
            //Durée uniquement si tache unitaire
            if ((typeid(**it2) ==  typeid(TacheUnitaire)) || (typeid(**it2) == typeid(TachePreemptable))){
                QString str;
                str.setNum((*it2)->getDuree().getDureeEnMinutes());
                stream.writeTextElement("duree",str);
            }

            //Programmation si la tâche est programmée
            if ((*it2)->getStatus()){ // La Tache est programmée nous écrivons ici sa programmation
                Programmation* prog = A.trouverProgrammation(*it2);
                if (prog){
                    stream.writeStartElement("programmation");
                    stream.writeTextElement("date",prog->getDate().toString(Qt::ISODate));
                    stream.writeTextElement("heure", prog->getHoraire().toString());
                    stream.writeEndElement(); // Fin <programmation>
                }
            }

            stream.writeEndElement();// Fin <tache>
        }
        stream.writeEndElement(); // Fin <taches>
        stream.writeEndElement(); // Fin <projet>
    }
    stream.writeEndElement(); // Fin <projets>

    //Liste des précédences de Taches dans la balise <precedences>
    stream.writeStartElement("precedences");
    for(ProjetManager::projets_iterator it1 = PM.begin_projets() ; it1 != PM.end_projets() ; ++it1){ //Itération sur les projets
        for(Projet::taches_iterator it2 = (*it1)->begin_taches() ; it2 != (*it1)->end_taches() ; ++it2){ //Itération sur les taches du projet
            if ((*it2)->withPrecedence()){ //La tache a des contraintes de precedence
                stream.writeStartElement("precedence");
                stream.writeAttribute("id_projet", (*it1)->getId());
                stream.writeAttribute("id_tache", (*it2)->getId());
                for(precedences_iterator it3 = (*it2)->begin_precedences() ; it3 != (*it2)->end_precedences() ; ++it3) //Pour chaque tache, itération sur les taches précédentes
                    stream.writeTextElement("id_precedence", (*it3)->getId());
                stream.writeEndElement(); // Fin <precedence>
            }
        }
    }
    stream.writeEndElement(); // Fin <precedences>

    //Liste des composants pour les taches compositees
    stream.writeStartElement("composites");
    for(ProjetManager::projets_iterator it1 = PM.begin_projets() ; it1 != PM.end_projets() ; ++it1){ //Itération sur les projets
        for(Projet::taches_iterator it2 = (*it1)->begin_taches() ; it2 != (*it1)->end_taches() ; ++it2){ //Itération sur les taches du projet
            if (typeid(**it2) == typeid(TacheComposite)){
                soustaches_iterator it3 = (*it2)->begin_soustaches();
                if (it3 != (*it2)->end_soustaches()) { //on teste si la tache a des taches composants
                    stream.writeStartElement("composite");
                    stream.writeAttribute("id_projet", (*it1)->getId());
                    stream.writeAttribute("id_tache", (*it2)->getId());
                    for(it3 = (*it2)->begin_soustaches() ; it3 != (*it2)->end_soustaches() ; ++it3) //Pour chaque tache, itération sur les sous taches
                        stream.writeTextElement("id_composant", (*it3)->getId());
                    stream.writeEndElement(); // Fin <composite>
                }
            }
        }
    }
    stream.writeEndElement(); // Fin <composites>

    //Liste des activités et de leurs programmations
    stream.writeStartElement("activites");
    ActiviteManager& AM = ActiviteManager::getInstance();
    for(ActiviteManager::activites_iterator it1 = AM.begin_activites() ; it1 != AM.end_activites() ; ++it1){
        stream.writeStartElement("activite");
        //Met l'attribut reunion à true si c'est une reunion, false sinon
        if (typeid(**it1) == typeid(Reunion))
            stream.writeAttribute("reunion", "true");
        else
            stream.writeAttribute("reunion", "false");
        //Met l'attribut rdv à true si c'est un rdv, false sinon
        if (typeid(**it1) == typeid(Rdv))
            stream.writeAttribute("rdv", "true");
        else
            stream.writeAttribute("rdv", "false");
        stream.writeTextElement("identificateur",(*it1)->getId());
        stream.writeTextElement("titre",(*it1)->getTitre());
        stream.writeTextElement("disponibilite",(*it1)->getDate().toString(Qt::ISODate));
        stream.writeTextElement("echeance",(*it1)->getEcheance().toString(Qt::ISODate));
        QString str;
        str.setNum((*it1)->getDuree().getDureeEnMinutes());
        stream.writeTextElement("duree",str);
        stream.writeTextElement("lieu",(*it1)->getLieu());
        if (typeid(**it1) == typeid(Reunion)){ // C'est un réunion, on ajoute la liste des participants
            stream.writeStartElement("participants");
            //for(int i = 0 ; i < (*it1)->getNbParticipants() ; i++){
            for(participants_iterator it2 = (*it1)->begin_participants() ; it2 != (*it1)->end_participants() ; ++it2){
                stream.writeTextElement("participant",*it2);
            }
            stream.writeEndElement();// Fin <participants
        }
        if (typeid(**it1) == typeid(Rdv)){ //C'est un rdv, on ajoute l'interlocuteur du rdv
            stream.writeTextElement("interlocuteur", (*it1)->getInterlocuteur());
        }
        //Programmation si l'activité est programmée
        if ((*it1)->getStatus()){ // L'a Tache 'activité est programmée nous écrivons ici sa programmation
            Programmation* prog = A.trouverProgrammation(*it1);
            if (prog){
                stream.writeStartElement("programmation");
                stream.writeTextElement("date",prog->getDate().toString(Qt::ISODate));
                stream.writeTextElement("heure", prog->getHoraire().toString());
                stream.writeEndElement(); // Fin <programmation>
            }
        }
        stream.writeEndElement(); // Fin <activite>
    }
    stream.writeEndElement(); // Fin <activites>
    stream.writeEndElement(); // Fin <projectcalendar>
    stream.writeEndDocument();
    newfile.close();
}