ptimetable_tex.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include <iomanip>
#include "platexobj_create.h"
 
#include "ptimetable_invitation.h"
#include "ptimetable_tex.h"
 
 
PString ptimetable_dateToStr(const PLatexDate & date){
        std::stringstream dateStr;
        dateStr << date.getYear() << "-" << std::setfill('0') << std::setw(2) << date.getMonth() << "-" << std::setfill('0') << std::setw(2) << date.getDay();
        return dateStr.str();
}
 
 
PString ptimetable_dateToText(const PLatexDate & date){
        std::stringstream dateStr;
        dateStr << std::setfill('0') << std::setw(2) << date.getDay()  << "/" << std::setfill('0') << std::setw(2) << date.getMonth() << "/" << date.getYear();
        return dateStr.str();
}
 
 
PString ptimetable_timeToStr(const PLatexTime & texTime){
        std::stringstream timeStr;
        timeStr << std::setfill('0') << std::setw(2) << texTime.getHour() << ":" << std::setfill('0') << std::setw(2) << texTime.getMinute();
        return timeStr.str();
}
 
 
void ptimetable_updateWeekLaterTime(TexWeek & week, const PLatexTime & texTime){
        PLatexTime & laterTime = week.laterTime;
        if(laterTime.getHour() < texTime.getHour()){
                laterTime = texTime;
        }else if(laterTime.getHour() == texTime.getHour()){
                if(laterTime.getMinute() < texTime.getMinute()){
                        laterTime = texTime;
                }
        }
}
 
 
void ptimetable_addBlockInWeek(TexWeek & week, const PTimeTableBlock & block, const PString & invitationTimeTable){
        PString blockDate(ptimetable_dateToStr(block.getDate()));
        PString beginTime(ptimetable_timeToStr(block.getBeginTime()));
        PString endTime(ptimetable_timeToStr(block.getEndTime()));
        ptimetable_updateWeekLaterTime(week, block.getEndTime());
        
        std::map<PString, TexDay> & mapDay = week.mapDay;
        std::map<PString, TexDay>::iterator it(mapDay.find(blockDate));
        if(it != mapDay.end()){
                it->second.mapBlock[beginTime] = block;
        }else{
                TexDay & day = mapDay[blockDate];
                day.date = block.getDate();
                day.invitation = invitationTimeTable + "_" + blockDate;
                day.mapBlock[beginTime] = block;
        }
        week.mapHour[beginTime] = "";
        week.mapHour[endTime] = "";
}
 
 
void ptimetable_createTexTimeTable(TexTimetable & texTimetable, const PTimeTable & timetable){
        const std::vector<PTimeTableBlock> & vecBlock = timetable.getVecBlock();
        std::vector<TexWeek> & vecWeek = texTimetable.vecWeek;
        
        PString invitationTimeTable(timetable.getInvitation());
        texTimetable.invitation = invitationTimeTable;
        TexWeek emptyWeek;
        emptyWeek.laterTime.setHour(0lu);
        emptyWeek.laterTime.setMinute(0lu);
        vecWeek.push_back(emptyWeek);
        //TODO : here we need to deal with untitled weeks
        //If no week has a title we have to dispatch days in month, or let say by 6-7 on a row to avoid too large generated web site
        for(std::vector<PTimeTableBlock>::const_iterator it(vecBlock.begin()); it != vecBlock.end(); ++it){
                if(it->getWeekTitle().getVecContent().size() != 0lu){
                        vecWeek.push_back(emptyWeek);
                        vecWeek.back().weekTitle = it->getWeekTitle();
                        vecWeek.back().invitation = it->getInvitation();
                }
                if(it->getTitle().getVecContent().size() != 0lu){
                        ptimetable_addBlockInWeek(vecWeek.back(), *it, invitationTimeTable);
                }
        }
        //Create the map of speakers
        const std::vector<PLatexSpeaker> & vecSpeaker = timetable.getVecSpeaker();
        for(std::vector<PLatexSpeaker>::const_iterator it(vecSpeaker.begin()); it != vecSpeaker.end(); ++it){
                texTimetable.mapSpeaker[it->getLabel()] = *it;
        }
}
 
 
bool ptimetable_checkBlockExist(const PTimeTableBlock *& foundBlock, const std::map<PString, PTimeTableBlock> & mapBlock, const PString & timeText){
        std::map<PString, PTimeTableBlock>::const_iterator it(mapBlock.find(timeText));
        if(it != mapBlock.end()){
                foundBlock = &(it->second);
                return true;
        }else{
                foundBlock = NULL;
                return false;
        }
}
 
 
void ptimetable_compelteDayEmptyBlock(TexDay & day, const std::map<PString, PString> & mapHour){
        std::map<PString, PTimeTableBlock> & mapBlock = day.mapBlock;
        //Let's iterate over times of the week
        std::map<PString, PString>::const_iterator itHour(mapHour.begin());
        while(itHour != mapHour.end()){
                PString currentTime(itHour->first);
                //Let's check if we found a correspondingblock at this time
                const PTimeTableBlock * foundBlock = NULL;
                if(ptimetable_checkBlockExist(foundBlock, mapBlock, currentTime)){
                        //A block has been found, we can jump until its end
                        PString endTime(ptimetable_timeToStr(foundBlock->getEndTime()));
                        //Normally the endtime should exist in mapHour
                        itHour = mapHour.find(endTime);
                }else{
                        //No block found, ew have to add an empty block
                        PTimeTableBlock emptyBlock;
                        emptyBlock.setIsEmptyBlock(true);
                        mapBlock[currentTime] = emptyBlock;
                        ++itHour;
                }
        }
}
 
 
void ptimetable_completeEmptyBlock(TexTimetable & texTimetable){
        //Let's iterate over weeks
        std::vector<TexWeek> & vecWeek = texTimetable.vecWeek;
        for(std::vector<TexWeek>::iterator itWeek(vecWeek.begin()); itWeek != vecWeek.end(); ++itWeek){
                //Let's iterate over days
                std::map<PString, TexDay> & mapDay = itWeek->mapDay;
                std::map<PString, PString> & mapHour = itWeek->mapHour;
                for(std::map<PString, TexDay>::iterator itDay(mapDay.begin()); itDay != mapDay.end(); ++itDay){
                        ptimetable_compelteDayEmptyBlock(itDay->second, mapHour);
                }
        }
}
 
 
void ptimetable_updateBlockTimeRow(PTimeTableBlock & block, const std::map<PString, PString> & mapHour){
        PString beginTime(ptimetable_timeToStr(block.getBeginTime()));
        PString endTime(ptimetable_timeToStr(block.getEndTime()));
        
        std::map<PString, PString>::const_iterator itBeginTime = mapHour.find(beginTime);
        std::map<PString, PString>::const_iterator itEndTime = mapHour.find(endTime);
        if(itBeginTime != mapHour.end() && itEndTime != mapHour.end()){
                size_t nbHourBlock(0lu);
                for(std::map<PString, PString>::const_iterator it(itBeginTime); it != itEndTime && it != mapHour.end(); ++it){
                        ++nbHourBlock;
                }
                block.setNbTimeRow(nbHourBlock);
        }
}
 
 
void ptimetable_updateTimeRow(TexTimetable & texTimetable){
        //Let's iterate over weeks
        std::vector<TexWeek> & vecWeek = texTimetable.vecWeek;
        for(std::vector<TexWeek>::iterator itWeek(vecWeek.begin()); itWeek != vecWeek.end(); ++itWeek){
                //Let's iterate over days
                std::map<PString, TexDay> & mapDay = itWeek->mapDay;
                std::map<PString, PString> & mapHour = itWeek->mapHour;
                for(std::map<PString, TexDay>::iterator itDay(mapDay.begin()); itDay != mapDay.end(); ++itDay){
                        //Let's iterate over blocks
                        std::map<PString, PTimeTableBlock> & mapBlock = itDay->second.mapBlock;
                        for(std::map<PString, PTimeTableBlock>::iterator itBlock(mapBlock.begin()); itBlock != mapBlock.end(); ++itBlock){
                                ptimetable_updateBlockTimeRow(itBlock->second, mapHour);
                        }
                }
        }
}
 
 
void ptimetable_blockToTex(PLatexObj & obj, const PTimeTableBlock & block){
        if(block.getIsEmptyBlock()){
                obj.setType(PLatexType::TIMETABLE_EMPTYBLOCK);
                return;
        }
        obj.setType(PLatexType::TIMETABLE_BLOCK);
        obj.setRowSpan(block.getNbTimeRow());
        
        if(block.getStyle() != ""){
                obj.setText(block.getStyle());
        }
        std::vector<PLatexObj> & vecContent = obj.getVecContent();
        if(block.getVecSpeaker().size() != 0lu){
                if(block.getInvitation() != ""){
                        vecContent.push_back(platexobj_createRendezVous(PPath(LATEX_INVITATION_OUTPUT_DIR "/" + block.getInvitation() + ".ics")));
                        vecContent.push_back(platexobj_createRef("sec_" + block.getInvitation(), block.getTitle()));
                }
        }else{
                vecContent = block.getTitle().getVecContent();
        }
}
 
 
void ptimetable_createTabCell(PLatexObj & cell, const PString & text){
        cell.setType(PLatexType::TIMETABLE_BLOCK);
        
        PLatexObj textObj;
        textObj.setType(PLatexType::TEXT);
        textObj.setText(text);
        cell.getVecContent().push_back(textObj);
}
 
 
void ptimetable_toTex(PLatexObj & obj, const TexTimetable & texTimetable){
        //std::vector<PString> vecDay{"Monday", "Tuesday", "Wednesday", "Thrusday", "Friday", "Saturday", "Sunday"};
        obj.setType(PLatexType::TIMETABLE);
        obj.setLabelName(texTimetable.invitation);
        const std::vector<TexWeek> & vecWeek = texTimetable.vecWeek;
        for(std::vector<TexWeek>::const_iterator itWeek(vecWeek.begin()); itWeek != vecWeek.end(); ++itWeek){
                if(itWeek->mapDay.size() == 0lu){continue;}
                PLatexObj weekObj;
                weekObj.setType(PLatexType::TIMETABLE_WEEK);
                if(itWeek->invitation != ""){
                        weekObj.getComplexTitle().push_back(platexobj_createRendezVous(PPath(LATEX_INVITATION_OUTPUT_DIR "/" + itWeek->invitation + ".ics")));
                        weekObj.getComplexTitle().push_back(platexobj_createRef("sec_"+itWeek->invitation, itWeek->weekTitle));
                        weekObj.setLabelName(itWeek->invitation);
                }
                
                const std::map<PString, PString> & mapHour = itWeek->mapHour;
                const std::map<PString, TexDay> & mapDay = itWeek->mapDay;
                //Header of the week (days)
                PLatexObj weekRowHeader(platexobj_createTimetableTimeRow());
                weekRowHeader.getVecContent().push_back(platexobj_createTimetableBlock("timetableDayStyle", platexobj_createText("Period/Day")));
                
                for(std::map<PString, TexDay>::const_iterator itDay(mapDay.begin()); itDay != mapDay.end(); ++itDay){
                        const PLatexDate & date = itDay->second.date;
                        std::stringstream dateStr;
                        dateStr << std::setfill('0') << std::setw(2) << date.getDay() << "/" << std::setfill('0') << std::setw(2) << date.getMonth() << "/" << date.getYear();
                        
                        PLatexObj contentBlock(platexobj_createNone());
                        if(itDay->second.invitation != ""){
                                contentBlock.getVecContent().push_back(platexobj_createRendezVous(PPath(LATEX_INVITATION_OUTPUT_DIR "/" + itDay->second.invitation + ".ics")));
                                contentBlock.getVecContent().push_back(platexobj_createRef("sec_" + itDay->second.invitation, dateStr.str()));
                        }
                        
                        PLatexObj refTimetableBlock(platexobj_createTimetableBlock("timetableDayStyle", contentBlock));
                        weekRowHeader.getVecContent().push_back(refTimetableBlock);
                }
                weekObj.getVecContent().push_back(weekRowHeader);
                
                //Timetable with hours
                for(std::map<PString, PString>::const_iterator itHour(mapHour.begin()); itHour != mapHour.end(); ++itHour){
                        PLatexObj timeRowObj;
                        timeRowObj.setType(PLatexType::TIMETABLE_TIMEROW);
                        
                        PLatexObj textTime;
                        textTime.setText(itHour->first);
                        textTime.setType(PLatexType::TIMETABLE_TIME);
                        timeRowObj.getVecContent().push_back(textTime);
                        
                        size_t i(0lu);
                        for(std::map<PString, TexDay>::const_iterator itDay(mapDay.begin()); itDay != mapDay.end(); ++itDay){
                                //For each day we have to find which block starts at the given hour time
                                const std::map<PString, PTimeTableBlock> & mapBlock = itDay->second.mapBlock;
                                std::map<PString, PTimeTableBlock>::const_iterator itBlock(mapBlock.find(itHour->first));
                                if(itBlock != mapBlock.end()){  //We found a corresponding block
                                        PLatexObj blockObj;
                                        ptimetable_blockToTex(blockObj, itBlock->second);
                                        timeRowObj.getVecContent().push_back(blockObj);
                                }
                                ++i;
                        }
                        weekObj.getVecContent().push_back(timeRowObj);
                }
                obj.getVecContent().push_back(weekObj);
        }
}
 
 
void ptimetable_singleDay(TexDay & out, std::map<PString, PString> & mapHour, const TexDay & day){
        out.date = day.date;
        out.invitation = day.invitation;
        const std::map<PString, PTimeTableBlock> & mapBlock = day.mapBlock;
        for(std::map<PString, PTimeTableBlock>::const_iterator it(mapBlock.begin()); it != mapBlock.end(); ++it){
                if(it->second.getIsEmptyBlock()){continue;}
                PString beginTime(ptimetable_timeToStr(it->second.getBeginTime()));
                mapHour[beginTime] = "";
                mapHour[ptimetable_timeToStr(it->second.getEndTime())] = "";
                PTimeTableBlock block(it->second);
                block.setNbTimeRow(1lu);
                out.mapBlock[beginTime] = block;
        }
        
}
 
 
void ptimetable_texLecture(std::vector<PLatexObj> & vecContent, const PTimeTableBlock & block, const TexTimetable & texTimetable){
        if(block.getVecSpeaker().size() == 0lu){return;}
        vecContent.push_back(platexobj_createSection(PLatexType::SUBSECTION, block.getTitle(), "sec_"+block.getInvitation()));
        if(block.getInvitation() != ""){
                vecContent.push_back(platexobj_createRendezVous(PPath(LATEX_INVITATION_OUTPUT_DIR "/" + block.getInvitation() + ".ics")));
        }
        vecContent.push_back(platexobj_createTextBf("Date", ""));
        vecContent.push_back(platexobj_createText(" : "+ptimetable_dateToText(block.getDate()), ""));
        vecContent.push_back(platexobj_createNewLine());
        vecContent.push_back(platexobj_createTextBf("Location", ""));
        vecContent.push_back(platexobj_createText(" : ", ""));
        vecContent.push_back(block.getLocation());
        vecContent.push_back(platexobj_createNewLine());
        vecContent.push_back(platexobj_createTextBf("Start at", ""));
        vecContent.push_back(platexobj_createText(" : "+ptimetable_timeToStr(block.getBeginTime()), ""));
        vecContent.push_back(platexobj_createNewLine());
        vecContent.push_back(platexobj_createTextBf("Stop at", ""));
        vecContent.push_back(platexobj_createText(" : "+ptimetable_timeToStr(block.getEndTime()), ""));
        
        
        vecContent.push_back(platexobj_createSection(PLatexType::SUBSUBSECTIONSTAR, platexobj_createText("Speakers",""), ""));
        PLatexObj listSpeaker(platexobj_createItemize());
        const std::vector<PString> & vecSpeaker = block.getVecSpeaker();
        const std::map<PString, PLatexSpeaker> & mapSpeaker = texTimetable.mapSpeaker;
        for(std::vector<PString>::const_iterator itSpeaker(vecSpeaker.begin()); itSpeaker != vecSpeaker.end(); ++itSpeaker){
                std::map<PString, PLatexSpeaker>::const_iterator it(mapSpeaker.find(*itSpeaker));
                if(it != mapSpeaker.end()){
                        const PLatexSpeaker & speaker = it->second;
                        listSpeaker.getVecContent().push_back(platexobj_createItem(platexobj_createRef("speaker_"+*itSpeaker, speaker.getName())));
                }else{
                        std::cerr << "ptimetable_texLecture : speaker '"<<(*itSpeaker)<<"' not found in map of speakers" << std::endl;
                }
        }
        vecContent.push_back(listSpeaker);
        if(block.getDescription().getVecContent().size() != 0lu){
                vecContent.push_back(platexobj_createSection(PLatexType::SUBSUBSECTIONSTAR, platexobj_createText("Description",""), ""));
                vecContent.push_back(platexobj_createParagraph(block.getDescription(), ""));
        }
}
 
 
void ptimetable_texSection(std::vector<PLatexObj> & vecContent, const TexDay & day,
                        const TexTimetable & texTimetable, const TexWeek & week)
{
        PLatexObj sectionTitle(platexobj_createSection(PLatexType::SECTION, platexobj_createText(ptimetable_dateToText(day.date), ""), "sec_"+day.invitation));
        vecContent.push_back(sectionTitle);
        if(day.invitation != ""){
                vecContent.push_back(platexobj_createRendezVous(PPath(LATEX_INVITATION_OUTPUT_DIR "/" + day.invitation + ".ics")));
        }
        
        TexWeek weekTimeTable;
        weekTimeTable.invitation = week.invitation;
        weekTimeTable.weekTitle = week.weekTitle;
        
        TexDay outDay;
        ptimetable_singleDay(outDay, weekTimeTable.mapHour, day);
        weekTimeTable.mapDay[ptimetable_dateToStr(outDay.date)] = outDay;
        
        //Now we create a TexTimetable with the current day
        TexTimetable dayTimetable;
        dayTimetable.invitation = texTimetable.invitation;
        dayTimetable.vecWeek.push_back(weekTimeTable);
        
        PLatexObj timetableObj;
        ptimetable_toTex(timetableObj, dayTimetable);
        vecContent.push_back(timetableObj);
        
        const std::map<PString, PTimeTableBlock> & mapBlock = day.mapBlock;
        for(std::map<PString, PTimeTableBlock>::const_iterator it(mapBlock.begin()); it != mapBlock.end(); ++it){
                if(it->second.getIsEmptyBlock()){continue;}
                ptimetable_texLecture(vecContent, it->second, texTimetable);
        }
}
 
 
 
void ptimetable_texChapter(std::vector<PLatexObj> & vecContent, const TexWeek & week, const TexTimetable & texTimetable){
        if(week.weekTitle.getVecContent().size() != 0lu){
                PLatexObj chapterTitle(platexobj_createSection(PLatexType::CHAPTER, week.weekTitle, "sec_"+week.invitation));
                vecContent.push_back(chapterTitle);
        }
        if(week.invitation != ""){
                vecContent.push_back(platexobj_createRendezVous(PPath(LATEX_INVITATION_OUTPUT_DIR "/" + week.invitation + ".ics")));
        }
        if(week.weekTitle.getVecContent().size() != 0lu){
                //Now we create a TexTimetable with the current week
                TexTimetable weekTimetable;
                weekTimetable.invitation = texTimetable.invitation;
                weekTimetable.vecWeek.push_back(week);
                PLatexObj timetableObj;
                ptimetable_toTex(timetableObj, weekTimetable);
                vecContent.push_back(timetableObj);
        }
        const std::map<PString, TexDay> & mapDay = week.mapDay;
        for(std::map<PString, TexDay>::const_iterator itDay(mapDay.begin()); itDay != mapDay.end(); ++itDay){
                ptimetable_texSection(vecContent, itDay->second, texTimetable, week);
        }
}
 
 
 
void ptimetable_texPart(std::vector<PLatexObj> & vecContent, const TexTimetable & texTimetable){
        const std::vector<TexWeek> & vecWeek = texTimetable.vecWeek;
        for(std::vector<TexWeek>::const_iterator itWeek(vecWeek.begin()); itWeek != vecWeek.end(); ++itWeek){
                if(itWeek->mapDay.size() == 0lu){continue;}
                ptimetable_texChapter(vecContent, *itWeek, texTimetable);
        }
}
 
 
bool ptimetable_tex(std::vector<PLatexObj> & vecContent, const PTimeTable & timetable, const PPath & outputDirectory, bool isSaveSpeaker){
        //Let's convert the PTimeTable into a more precise representation
        TexTimetable texTimetable;
        std::cerr << "ptimetable_tex : call ptimetable_createTexTimeTable" << std::endl;
        ptimetable_createTexTimeTable(texTimetable, timetable);
        //Add empty block to make days coherent
        std::cerr << "ptimetable_tex : call ptimetable_completeEmptyBlock" << std::endl;
        ptimetable_completeEmptyBlock(texTimetable);
        //Update the size of the blocks in the timetable
        std::cerr << "ptimetable_tex : call ptimetable_updateTimeRow" << std::endl;
        ptimetable_updateTimeRow(texTimetable);
        //Let's put all block in the vecContent
        std::cerr << "ptimetable_tex : call ptimetable_toTex" << std::endl;
        PLatexObj timetableObj;
        ptimetable_toTex(timetableObj, texTimetable);
        vecContent.push_back(platexobj_createSection(PLatexType::PART, timetable.getName(), "sec_"+timetable.getInvitation()));
        if(texTimetable.invitation != ""){
                vecContent.push_back(platexobj_createRendezVous(PPath(LATEX_INVITATION_OUTPUT_DIR "/" + texTimetable.invitation + ".ics")));
        }
        vecContent.push_back(timetableObj);
        ptimetable_texPart(vecContent, texTimetable);
        if(isSaveSpeaker){
                pspeaker_tex(vecContent, timetable);
        }
        return ptimetable_createInvitationMergBlock(outputDirectory, texTimetable);
//      return ptimetable_createInvitation(outputDirectory, texTimetable);
}