//----------------------------------------------------------------------------------------
private List <CTrancheHoraire> TraitePrioritesTranches(List <CTrancheHoraire> listeATraiter)
{
List <CTrancheHoraire> listeTraitee = new List <CTrancheHoraire>();
// Parcoure les évenements temporels de début et de fin de tranche
List <CChangementTranche> lstChangementTranches = new List <CChangementTranche>();
foreach (CTrancheHoraire tranche in listeATraiter)
{
lstChangementTranches.Add(new CChangementTranche(tranche.DateHeureDebut, tranche, CChangementTranche.EChangement.Debut));
lstChangementTranches.Add(new CChangementTranche(tranche.DateHeureFin, tranche, CChangementTranche.EChangement.Fin));
}
lstChangementTranches.Sort(new CChangementTranche.ComparateurSurDateHeure());
// On construit les nouvelles tranches horaires en foncion des priorités
CListeTranchesHoraires listeTempon = new CListeTranchesHoraires();
// Priorité en cours initialisée à -1 pour forcer le démarrage du processus
int nPrioriteEnCours = -1;
CTrancheHoraire trancheEnCours = null;
foreach (CChangementTranche evenement in lstChangementTranches)
{
int nNouvellePriorite = -2;
bool bCreateNext = false;
if (evenement.changement == CChangementTranche.EChangement.Debut)
{
if (!listeTempon.Contains(evenement.Tranche))
{
listeTempon.AddAndSort(evenement.Tranche);
}
nNouvellePriorite = listeTempon[0].Priorite;
//nNouvellePriorite = tpOccup != null ? tpOccup.Priorite : 0;
bCreateNext = true;
}
else
{
if (listeTempon.Contains(evenement.Tranche))
{
listeTempon.Remove(evenement.Tranche);
}
if (listeTempon.Count > 0)
{
nNouvellePriorite = listeTempon[0].Priorite;
//nNouvellePriorite = tpOccup != null ? tpOccup.Priorite : 0;
bCreateNext = true;
}
else
{
nPrioriteEnCours = -1;
nNouvellePriorite = -2;
bCreateNext = false;
}
}
// La priorité la plus haute est toujours au début de la liste
if (nNouvellePriorite != nPrioriteEnCours)
{
// On change de tranche
if (trancheEnCours != null)
{
// "Ferme" la tranche en cours et l'ajoute à la liste finale
trancheEnCours.DateHeureFin = evenement.DateHeure;
listeTraitee.Add(trancheEnCours);
trancheEnCours = null;
}
if (bCreateNext)
{
// "Ouvre" une nouvelle tranche
trancheEnCours = new CTrancheHoraire();
trancheEnCours.DateHeureDebut = evenement.DateHeure;
trancheEnCours.TypeOccupationHoraire = listeTempon[0].TypeOccupationHoraire;
nPrioriteEnCours = nNouvellePriorite;
}
}
}
return(listeTraitee);
}
public CChangementTranche(DateTime dt, CTrancheHoraire tr, EChangement ch)
{
DateHeure = dt;
Tranche = tr;
changement = ch;
}
public CTrancheHoraire[] GetHoraires(DateTime debut, DateTime fin)
{
Dictionary <string, CCalendrier_JourParticulier> dicJours = GetDicJoursParticuliers();
if ((debut == null) || (fin == null) || (fin < debut) || this.HoraireParDefaut == null)
{
return(new CTrancheHoraire[0]);
}
List <CTrancheHoraire> listeTranches = new List <CTrancheHoraire>();
// Recherche les EO planifiées de l'Acteur du calendrier s'il y en a un
if (Acteur != null)
{
listeTranches.AddRange(Acteur.GetHorairesSansCalendrier(debut, fin));
}
// Traitement du jour précedent la date de début
IElementATrancheHoraire jourPrecedentDebut =
(IElementATrancheHoraire)GetJourParticulierAvecHeritageOptim(debut.Date.AddDays(-1), dicJours);
if (jourPrecedentDebut == null)
{
jourPrecedentDebut = (IElementATrancheHoraire)this.HoraireParDefaut;
}
foreach (CHoraireJournalier_Tranche tranche in jourPrecedentDebut.TranchesHorairesListe)
{
if (tranche.HeureFin < tranche.HeureDebut)
{
// La tranche est à cheval sur deux jours
CTrancheHoraire newTranche = new CTrancheHoraire();
// Heure de début tronquée à 00:00:00
newTranche.DateHeureDebut = debut.Date.AddDays(-1); // La veille
newTranche.DateHeureDebut = newTranche.DateHeureDebut.AddMinutes(tranche.HeureDebut);
// Heure de fin le jour de début
newTranche.DateHeureFin = debut.Date;
newTranche.DateHeureFin = newTranche.DateHeureFin.AddMinutes(tranche.HeureFin);
newTranche.TypeOccupationHoraire = tranche.TypeOccupationHoraireAppliquee;
if (newTranche.TypeOccupationHoraire == null)
{
newTranche.TypeOccupationHoraire = this.TypeOccupationHoraireAppliquee;
}
//Ajout la tranche à la liste
if (newTranche.DateHeureFin >= debut && newTranche.DateHeureDebut <= fin)
{
listeTranches.Add(newTranche);
}
}
}
// Pour chaque jour entre la date de début et de fin inclus
for (DateTime date = debut.Date; date <= fin.Date; date = date.AddDays(1))
{
// Traite les tranches horaires du Calendrier de l'Acteur
IElementATrancheHoraire jour = (IElementATrancheHoraire)GetJourParticulierAvecHeritageOptim(date, dicJours);
if (jour == null)
{
jour = (IElementATrancheHoraire)this.HoraireParDefaut;
}
if (jour != null)
{
jour = jour.ElementATrancheHoraireApplique;
}
if (jour != null)
{
if (jour.TranchesHorairesListe.Count == 0)
{
//Regle : si un jour particulier n'a pas d'horaires, alors,
//il prend l'horaire de ce jour dans le calendrier de base
List <CTrancheHoraire> tranches = new List <CTrancheHoraire>();
if (CalendrierDeBase != null)
{
tranches.AddRange(CalendrierDeBase.GetHoraires(date, date.AddDays(1)));
}
else
{
foreach (CHoraireJournalier_Tranche ht in HoraireParDefaut.TranchesHorairesListe)
{
CTrancheHoraire newTranche = new CTrancheHoraire();
newTranche.TypeOccupationHoraire = jour.TypeOccupationHoraire;
newTranche.DateHeureDebut = date.Date;
newTranche.DateHeureDebut = newTranche.DateHeureDebut.AddMinutes(ht.HeureDebut);
// On ne prend que celles qui commencent ce jour là
newTranche.DateHeureFin = (ht.HeureFin > ht.HeureDebut) ?
date.Date : date.AddDays(1).Date;
newTranche.DateHeureFin = newTranche.DateHeureFin.AddMinutes(ht.HeureFin);
tranches.Add(newTranche);
}
}
foreach (CTrancheHoraire tr in tranches)
{
if (tr.DateHeureDebut < fin && tr.DateHeureFin > debut)
{
CTrancheHoraire newTranche = new CTrancheHoraire();
newTranche.DateHeureDebut = tr.DateHeureDebut;
newTranche.DateHeureFin = tr.DateHeureFin;
newTranche.TypeOccupationHoraire = jour.TypeOccupationHoraire;
if (newTranche.TypeOccupationHoraire == null)
{
newTranche.TypeOccupationHoraire = this.TypeOccupationHoraireAppliquee;
}
listeTranches.Add(newTranche);
}
}
}
else
{
foreach (CHoraireJournalier_Tranche tranche in jour.TranchesHorairesListe)
{
CTrancheHoraire newTranche = new CTrancheHoraire();
newTranche.DateHeureDebut = date.Date;
newTranche.DateHeureDebut = newTranche.DateHeureDebut.AddMinutes(tranche.HeureDebut);
// On ne prend que celles qui commencent ce jour là
newTranche.DateHeureFin = (tranche.HeureFin > tranche.HeureDebut) ?
date.Date : date.AddDays(1).Date;
newTranche.DateHeureFin = newTranche.DateHeureFin.AddMinutes(tranche.HeureFin);
newTranche.TypeOccupationHoraire = tranche.TypeOccupationHoraireAppliquee;
if (newTranche.TypeOccupationHoraire == null)
{
newTranche.TypeOccupationHoraire = this.TypeOccupationHoraireAppliquee;
}
if (newTranche.DateHeureFin >= debut && newTranche.DateHeureDebut <= fin)
{
listeTranches.Add(newTranche);
}
}
}
}
}
// Traitement des priorités
List <CTrancheHoraire> listeTraitee = TraitePrioritesTranches(listeTranches);
listeTraitee.Sort(new CTrancheHoraire.PrioriteComparer());
return((CTrancheHoraire[])listeTraitee.ToArray());
}
