Example #1
0
        public void RafraichirCompe()
        {
            string nomFichier    = ParamCommuns.Instance.NomFichierPat;
            string nomCompe      = ParamCommuns.Instance.NomCompetition;
            int    noCompt       = ParamCommuns.Instance.NoCompetition;
            string connectString = string.Format(@"Provider = Microsoft.Jet.OLEDB.4.0; Data Source = {0}; User Id = admin; Password =; ", nomFichier);

            try
            {
                using (DBPatinVitesse db = new DBPatinVitesse(connectString))
                {
                    DetailCompe(db, noCompt);
                }
            }
            catch (Exception e)
            {
                MessageBox.Show("Erreur de rafraichissement");
            }

            this.mwvms.AfficherResultatDefilement();
            //if (ParamCommuns.Instance.WebResultat == ParamCommuns.ModeDiffusion.Web || ParamCommuns.Instance.WebResultat == ParamCommuns.ModeDiffusion.BT)
            //{
            //    List<string> res = ResultatCompetitionMgr.Instance.ObtenirResultatCompetition();
            //    if (res != null && res.Count > 0)
            //    {
            //        mwvms.AfficherMessageWeb(Chat.ChronoSignalR.TypeMessage.Defilement1, string.Format("Résultats obtenus pour les groupes : {0}", string.Join(",", res)));
            //    }
            //}
        }
Example #2
0
        private void FichierPat_TextChanged(object sender, TextChangedEventArgs e)
        {
            string nomFichierPat = this.FichierPat.Text;

            if (System.IO.File.Exists(nomFichierPat))
            {
                this.softwareKey.SetValue("NomFichierPAT", nomFichierPat);
                ParamCommuns.Instance.NomFichierPat = nomFichierPat;
                //"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\Users\Bruno\Documents\Arpvq 2017-2018\TestsChrono\Publication.pat;User Id=admin;Password=;" providerName="System.Data.OleDb"
                string connectString = string.Format(@"Provider = Microsoft.Jet.OLEDB.4.0; Data Source = {0}; User Id = admin; Password =; ", nomFichierPat);
                using (DBPatinVitesse db = new DBPatinVitesse(connectString))
                {
                    var comps   = new List <string>();
                    var noComps = new List <int>();
                    foreach (Competition c in db.Competition)
                    {
                        comps.Add(c.Lieu);
                        noComps.Add(c.NoCompetition);
                    }
                    this.cbxCompetition.ItemsSource = comps;
                    ParamCommuns.Instance.Comps     = comps;
                    ParamCommuns.Instance.NoComps   = noComps;
                }
                if (this.softwareKey.GetValue("NoCompetition") != null)
                {
                    int noCompe = (int)this.softwareKey.GetValue("NoCompetition");
                    ParamCommuns.Instance.NoCompetition = noCompe;
                    this.cbxCompetition.SelectedIndex   = ParamCommuns.Instance.NoComps.IndexOf(noCompe);
                }
            }
        }
Example #3
0
        private static void watcher_EventArrived(object sender, EventArrivedEventArgs e)
        {
            if (fait)
            {
                return;
            }

            watcher.EventArrived -= watcher_EventArrived;
            Console.WriteLine("La clé USB a été insérée");
            SystemSounds.Beep.Play();

            while (true)
            {
                var availableDrives = DriveInfo.GetDrives()
                                      .Where(d => d.IsReady && d.DriveType == DriveType.Removable);
                foreach (var x in availableDrives)
                {
                    string[] resultat = Directory.GetFiles(x.Name, "*.pat");
                    if (resultat.Length == 0)
                    {
                        Console.WriteLine("Aucun fichier PAT sur la clé USB");
                        SystemSounds.Beep.Play();
                        SystemSounds.Beep.Play();
                        fait = true;
                        watcherOut.EventArrived += watcher_EventArrived2;
                        return;
                    }

                    if (resultat.Length > 1)
                    {
                        Console.WriteLine("La clé USB comporte plus d'un fichier, le premier fichier sera utilisé!");
                    }
                    string fichPat = resultat[0];
                    Console.WriteLine(string.Format("Le fichier {0} sera publié!", fichPat));
                    FileInfo fi      = new FileInfo(fichPat);
                    string   nomCopy = Path.Combine(ConfigurationManager.AppSettings["pathTravail"], "Publication.pat");
                    Console.WriteLine(string.Format("Avant la copie {0},{1}", fichPat, nomCopy));
                    File.Copy(fichPat, nomCopy, true);
                    Console.WriteLine("Apres la copie");
                    using (var db = new DBPatinVitesse())
                    {
                        PatineurCompe.DB = db;
                        PublicationResultat pr = new PublicationResultat();
                        pr.InfoCompeVagues(db);
                        Console.WriteLine("Mise à jour du site WEB");
                        pr.CopierSiteFTP();
                        Console.WriteLine("Fin de la mise à jour du site WEB");
                    }
                    SystemSounds.Beep.Play();
                    SystemSounds.Beep.Play();
                    Console.WriteLine("Vous pouvez maintenant retirer la clé USB");
                    fait = true;
                    watcherOut.EventArrived += watcher_EventArrived2;
                    return;
                }

                System.Threading.Thread.Sleep(1000);
            }
        }
Example #4
0
 private void cbxCompetition_SelectionChanged(object sender, SelectionChangedEventArgs e)
 {
     if (this.cbxCompetition.SelectedIndex != -1)
     {
         int    idx           = this.cbxCompetition.SelectedIndex;
         string connectString = string.Format(@"Provider = Microsoft.Jet.OLEDB.4.0; Data Source = {0}; User Id = admin; Password =; ", ParamCommuns.Instance.NomFichierPat);
         using (DBPatinVitesse db = new DBPatinVitesse(connectString))
         {
             int    noCompe  = ParamCommuns.Instance.NoComps[idx];
             string nomCompe = db.Competition.SingleOrDefault(z => z.NoCompetition == noCompe).Lieu;
             this.softwareKey.SetValue("NoCompetition", noCompe);
             ParamCommuns.Instance.NoCompetition = noCompe;
             this.softwareKey.SetValue("NomCompetition", nomCompe);
             ParamCommuns.Instance.NomCompetition = nomCompe;
             ProgrammeCourseMgr.Instance.DetailCompe(db, noCompe);
             this.ouvertureValidee = true;
         }
     }
 }
        public List <string> ObtenirResultatCompetition()
        {
            string connectString = string.Format(@"Provider = Microsoft.Jet.OLEDB.4.0; Data Source = {0}; User Id = admin; Password =; ", ParamCommuns.Instance.NomFichierPat);

            using (var db = new DBPatinVitesse(connectString))
            {
                string ftpUser    = ParamCommuns.Instance.UsagerFTP;
                string ftpPasse   = ParamCommuns.Instance.MotPasse;
                string ftpSite    = ParamCommuns.Instance.SiteFTP;
                string ftpTravail = ParamCommuns.Instance.TravailFTP;
                int    noCompe    = ParamCommuns.Instance.NoCompetition;
                bool   m          = ParamCommuns.Instance.GroupesMixtes;

                PatineurCompe.DB = db;
                PublicationResultat pr        = new PublicationResultat(noCompe, m, "json", ftpTravail, ftpSite, ftpUser, ftpPasse, ParamCommuns.Instance.WebResultat == ParamCommuns.ModeDiffusion.BT, BlueToothMgr.Instance.SendMessageBluetoothVersFTP);
                JObject             programme = null;
                programme = pr.InfoCompeVagues(db);
                return(pr.CopierSiteFTP(programme));
            }
        }
Example #6
0
        public void Obtenir(string nomFichier, out int noCompe, out string NomCompe)
        {
            noCompe  = -1;
            NomCompe = string.Empty;
            int noCompeInterne = -1;

            using (DBPatinVitesse db = new DBPatinVitesse(nomFichier))
            {
                ChoisirCompetition dialog = new ChoisirCompetition();
                //dialog.WindowStartupLocation = System.Windows.WindowStartupLocation.CenterOwner;
                dialog.ListCompe = new System.Collections.ObjectModel.ObservableCollection <string>(db.Competition.Select(z => z.Lieu).ToList());
                dialog.ShowDialog();
                if (dialog.DialogResult.HasValue && dialog.DialogResult.Value)
                {
                    string nom;
                    if (dialog.CompeSele == null)
                    {
                        nom = dialog.ListCompe.First();
                    }
                    else
                    {
                        nom = dialog.CompeSele;
                    }
                    NomCompe       = nom;
                    noCompe        = db.Competition.SingleOrDefault(z => z.Lieu == nom).NoCompetition;
                    noCompeInterne = noCompe;
                }
                else
                {
                    ParamCommuns.Instance.Programmes = null;
                    ParamCommuns.Instance.DescVagues = null;
                    return;
                }

                DetailCompe(db, noCompeInterne);
            }
        }
Example #7
0
        public void InfoCompeVagues(DBPatinVitesse db)
        {
            db.Competition.ToList().ForEach(z => Console.WriteLine(string.Format("No : {0}, Nom : {1}", z.NoCompetition, z.Lieu)));

            string noStrCompe = ConfigurationManager.AppSettings["NoCompe"];

            if (string.IsNullOrEmpty(noStrCompe))
            {
                Console.WriteLine("Entrer le numéro de compétition");
                noStrCompe = Console.ReadLine();
            }
            int noCompeti;

            if (int.TryParse(noStrCompe, out noCompeti))
            {
                var queryCompe =
                    from compe in db.Competition
                    where compe.NoCompetition == noCompeti
                    select compe;
                ;

                JObject programme = new JObject();
                programme.Add("Nom", queryCompe.First().Commentaire);
                JArray ja = new JArray();
                programme.Add("Groupes", ja);

                var pc = from progcourse in db.ProgCourses
                         where progcourse.NoCompetition == noCompeti
                         select progcourse.Groupe;

                var     grppreced     = string.Empty;
                var     vgpreced      = string.Empty;
                JArray  vaguesGroupes = new JArray();
                JArray  patineurVague = new JArray();
                JObject vagueJson     = null;

                // Sélection de tous les temps des patineurs de la compétition
                var laTotal = from patvag in db.PatVagues
                              join patcmp in db.PatineurCompe on patvag.NoPatCompe equals patcmp.NoPatCompe
                              join patineur in db.Patineur on patcmp.NoPatineur equals patineur.NoPatineur
                              join club in db.Club on patineur.NoClub equals club.NoClub
                              join vag in db.Vagues on patvag.CleTVagues equals vag.CleTVagues
                              join progcrs in db.ProgCourses on vag.CleDistancesCompe equals progcrs.CleDistancesCompe
                              join diststd in db.DistanceStandards on progcrs.NoDistance equals diststd.NoDistance
                              join cmnt in db.Commentaire on patvag.Juge equals cmnt.Code
                              where patvag.NoPatCompe == patcmp.NoPatCompe &&
                              patcmp.NoPatineur == patineur.NoPatineur &&
                              patineur.NoClub == club.NoClub &&
                              patvag.CleTVagues == vag.CleTVagues &&
                              vag.CleDistancesCompe == progcrs.CleDistancesCompe &&
                              progcrs.NoDistance == diststd.NoDistance &&
                              patcmp.NoCompetition == noCompeti &&
                              progcrs.NoCompetition == noCompeti
                              select new ResultatObj()
                {
                    NoPatineur      = patineur.NoPatineur,
                    Nom             = patineur.Nom + "," + patineur.Prenom,
                    Club            = club.NomClub,
                    NoCasque        = patvag.NoCasque,
                    Temps           = patvag.Temps,
                    Point           = patvag.Point,
                    Rang            = patvag.Rang,
                    Code            = cmnt.CodeAction.Replace("NIL", string.Empty),
                    NoVague         = vag.NoVague,
                    Epreuve         = vag.Qual_ou_Fin,
                    Groupe          = patcmp.Groupe,
                    LongueurEpreuve = diststd.LongueurEpreuve,
                    NoBloc          = progcrs.NoBloc,
                    Sexe            = patineur.Sexe
                };

                var nbp = laTotal.Count();

                //var laTotale1 = laTotal.OrderBy(z => z, comparer ).ThenBy(z => z.NoBloc).ThenBy(z => z.Rang).ThenBy(z => z.Point).ThenBy(z => z.NoCasque);
                //var laTotale1 = laTotal.OrderBy(z => z, comparer);
                //var laTotale1 = laTotal.OrderBy(z => z.Groupe).ThenBy(z => z.Sexe).ThenBy(z => z.ChiffreVague).ThenBy(z => z.LettreVague).ThenBy(z => z.NoBloc).ThenBy(z => z.Rang).ThenBy(z => z.Point).ThenBy(z => z.NoCasque);
                //var laTotale1 = laTotal.OrderBy(z => z.Groupe + z.Sexe + z.NoVague.PadLeft(6,'0') + z.NoBloc.ToString().PadLeft(3,'0') + z.Rang.ToString().PadLeft(4,'0')).ThenBy(z => z.Point).ThenBy(z => z.NoCasque);
                bool         m         = bool.Parse(ConfigurationManager.AppSettings["Mixte"]);
                TrieResultat comparer  = new TrieResultat(m);
                var          laTotale1 = laTotal.ToList().OrderBy(z => z, comparer).ToList();
                nbp = laTotale1.Count();
                var laTotale2 = laTotale1.ToList();
                nbp = laTotale2.Count();
                foreach (var ab in laTotale2)
                {
                    Console.WriteLine(string.Format("{0},{1},{2},{3},{4},{5},{6},{7},{8},{9},{10}", ab.Groupe, ab.NoVague, ab.Nom, ab.Rang, ab.Temps, ab.Point, ab.Club, ab.LongueurEpreuve, ab.Nom, ab.Epreuve, ab.Code));
                }

                var noGroupe = 0;
                Dictionary <int, ResultatObj> dictRes = new Dictionary <int, ResultatObj>();
                foreach (var ab in laTotale2)
                {
                    string nomgrp = ab.Groupe + " " + ab.Sexe.ToUpper();
                    if (m)
                    {
                        nomgrp = ab.Groupe;
                    }
                    if (grppreced != nomgrp)
                    {
                        // Si le groupe change, la vague change
                        if (vagueJson != null)
                        {
                            vaguesGroupes.Add(vagueJson);
                        }
                        vagueChange(out vgpreced, out patineurVague, out vagueJson, ab);
                        if (!string.IsNullOrEmpty(grppreced))
                        {
                            noGroupe += 1;
                            //string groupeData = vaguesGroupes.ToString();
                            CreerFichierResultatGroupe(noGroupe, vaguesGroupes, grppreced, (JArray)programme["Groupes"], dictRes);
                            dictRes = new Dictionary <int, ResultatObj>();
                        }
                        vaguesGroupes = new JArray();
                        grppreced     = nomgrp;
                        //vgpreced = ab.NoVague;
                    }
                    else if (vgpreced != ab.NoVague)
                    {
                        if (vagueJson != null)
                        {
                            vaguesGroupes.Add(vagueJson);
                        }
                        vagueChange(out vgpreced, out patineurVague, out vagueJson, ab);
                    }
                    if (dictRes.ContainsKey(ab.NoPatineur))
                    {
                        dictRes[ab.NoPatineur].Point += ab.Point;
                    }
                    else
                    {
                        dictRes.Add(ab.NoPatineur, new ResultatObj()
                        {
                            NoPatineur = ab.NoPatineur,
                            Nom        = ab.Nom,
                            Club       = ab.Club,
                            Point      = ab.Point,
                            Code       = ""
                        });
                    }

                    JObject patineurJson = new JObject();
                    patineurJson.Add("Casque", ab.NoCasque.ToString());
                    patineurJson.Add("Patineurs", ab.Nom);
                    patineurJson.Add("Club", ab.Club);
                    patineurJson.Add("Rang", ab.Rang);
                    patineurJson.Add("Temps", ab.Temps);
                    patineurJson.Add("Commentaire", ab.Code);
                    patineurJson.Add("Point", ab.Point);
                    patineurJson.Add("Date", "");
                    patineurVague.Add(patineurJson);
                    //Console.WriteLine(string.Format("{0},{1},{2},{3},{4},{5},{6},{7},{8},{9}", ab.Groupe, ab.NoVague, ab.Nom, ab.Rang, ab.Temps, ab.Point, ab.Club, ab.LongueurEpreuve, ab.Nom, ab.Etape));
                }

                // On termine avec le dernier groupe
                noGroupe += 1;
                if (vagueJson != null)
                {
                    vaguesGroupes.Add(vagueJson);
                }
                if (!string.IsNullOrEmpty(grppreced))
                {
                    //string groupeData = vaguesGroupes.ToString();
                    CreerFichierResultatGroupe(noGroupe, vaguesGroupes, grppreced, (JArray)programme["Groupes"], dictRes);
                }

                // Créer le fichier de programme
                string programmeStr = programme.ToString();
                programmeStr = programmeStr.Replace(Environment.NewLine, string.Empty);
                string extFich = "js";
                if (!string.IsNullOrEmpty(ConfigurationManager.AppSettings["Fmt"]) && ConfigurationManager.AppSettings["Fmt"] == "JSON")
                {
                    extFich = "json";
                }
                string nomficheprg         = string.Format("programme.{0}", extFich);
                string pathResultat        = Path.Combine(ConfigurationManager.AppSettings["pathTravail"], "ResultatsTravail", nomficheprg);
                string ResultatsPrecedents = Path.Combine(ConfigurationManager.AppSettings["pathTravail"], "ResultatsPrecedents", nomficheprg);
                string ResultatsFTP        = Path.Combine(ConfigurationManager.AppSettings["pathTravail"], "ResultatsFTP", nomficheprg);
                string newtext             = programmeStr;
                if (extFich == "js")
                {
                    newtext = string.Format("var a = '{0}';", programmeStr);
                }

                using (StreamWriter sr = new StreamWriter(pathResultat))
                {
                    sr.Write(newtext);
                }

                if (!System.IO.File.Exists(ResultatsPrecedents))
                {
                    // première copie du résultat
                    System.IO.File.Copy(pathResultat, ResultatsPrecedents);
                    System.IO.File.Copy(pathResultat, ResultatsFTP);
                }
                else
                {
                    string contenuGit = System.IO.File.ReadAllText(ResultatsPrecedents);
                    if (contenuGit != newtext)
                    {
                        System.IO.File.Delete(ResultatsPrecedents);
                        System.IO.File.Copy(pathResultat, ResultatsPrecedents);
                        System.IO.File.Copy(pathResultat, ResultatsFTP);
                    }
                }
                //List<string> ls = new List<string>();
            }
        }
Example #8
0
        public void DetailCompe(DBPatinVitesse db, int noCompeInterne)
        {
            var programmes = new ObservableCollection <ProgrammeCourse>();
            var descVagues = new Dictionary <string, List <PatineurVague> >();

            // Sélection de tous les temps des patineurs de la compétition
            var laTotal = from patvag in db.PatVagues
                          join patcmp in db.PatineurCompe on patvag.NoPatCompe equals patcmp.NoPatCompe
                          join patineur in db.Patineur on patcmp.NoPatineur equals patineur.NoPatineur
                          join club in db.Club on patineur.NoClub equals club.NoClub
                          join vag in db.Vagues on patvag.CleTVagues equals vag.CleTVagues
                          join progcrs in db.ProgCourses on vag.CleDistancesCompe equals progcrs.CleDistancesCompe
                          join diststd in db.DistanceStandards on progcrs.NoDistance equals diststd.NoDistance
                          join cmnt in db.Commentaire on patvag.Juge equals cmnt.Code
                          where patvag.NoPatCompe == patcmp.NoPatCompe &&
                          patcmp.NoPatineur == patineur.NoPatineur &&
                          patineur.NoClub == club.NoClub &&
                          patvag.CleTVagues == vag.CleTVagues &&
                          vag.CleDistancesCompe == progcrs.CleDistancesCompe &&
                          progcrs.NoDistance == diststd.NoDistance &&
                          patcmp.NoCompetition == noCompeInterne &&
                          progcrs.NoCompetition == noCompeInterne
                          select new ResultatObj()
            {
                NoPatineur      = patineur.NoPatineur,
                Nom             = patineur.Nom + "," + patineur.Prenom,
                Club            = club.NomClub,
                NoCasque        = patvag.NoCasque,
                Temps           = patvag.Temps,
                Point           = patvag.Point,
                Rang            = patvag.Rang,
                Code            = cmnt.CodeAction.Replace("NIL", string.Empty),
                NoVague         = vag.NoVague,
                Epreuve         = vag.Qual_ou_Fin,
                Groupe          = patcmp.Groupe,
                LongueurEpreuve = diststd.LongueurEpreuve,
                Distance        = diststd.Distance,
                NoBloc          = progcrs.NoBloc,
                Sexe            = patineur.Sexe
            };

            var nbp = laTotal.Count();

            System.Diagnostics.Debug.WriteLine(" t.ChiffreVague, t.Groupe, t.NoBloc, t.NoPatineur, t.Nom, t.LettreVague, t.NoCasque, t.ChiffreVague, t.texe");
            foreach (var t in laTotal)
            {
                System.Diagnostics.Debug.WriteLine(string.Format("{0},{1},{2},{3},{4},{5},{6},{7},{8}", t.ChiffreVague, t.Groupe, t.NoBloc, t.NoPatineur, t.Nom, t.LettreVague, t.NoCasque, t.ChiffreVague, t.Sexe));
            }


            bool         m         = ParamCommuns.Instance.GroupesMixtes; // bool.Parse(ConfigurationManager.AppSettings["Mixte"]);
            TrieResultat comparer  = new TrieResultat(m);
            var          laTotale1 = laTotal.ToList().OrderBy(z => z, comparer).ToList();

            nbp = laTotale1.Count();
            System.Diagnostics.Debug.WriteLine("--------");

            System.Diagnostics.Debug.WriteLine(" t.ChiffreVague, t.Groupe, t.NoBloc, t.NoPatineur, t.Nom, t.LettreVague, t.NoCasque, t.ChiffreVague, t.texe");
            foreach (var t in laTotale1)
            {
                System.Diagnostics.Debug.WriteLine(string.Format("{0},{1},{2},{3},{4},{5},{6},{7},{8}", t.ChiffreVague, t.Groupe, t.NoBloc, t.NoPatineur, t.Nom, t.LettreVague, t.NoCasque, t.ChiffreVague, t.Sexe));
            }

            var laTotale2 = laTotale1.ToList();

            nbp = laTotale2.Count();

            System.Diagnostics.Debug.WriteLine("--------");

            System.Diagnostics.Debug.WriteLine(" t.ChiffreVague, t.Groupe, t.NoBloc, t.NoPatineur, t.Nom, t.LettreVague, t.NoCasque, t.ChiffreVague, t.texe");
            foreach (var t in laTotale2)
            {
                System.Diagnostics.Debug.WriteLine(string.Format("{0},{1},{2},{3},{4},{5},{6},{7},{8}", t.ChiffreVague, t.Groupe, t.NoBloc, t.NoPatineur, t.Nom, t.LettreVague, t.NoCasque, t.ChiffreVague, t.Sexe));
            }

            if (m)
            {
                // course mixte, on se préocupe pas du sexe
                var b = laTotale2.Select(z => new { z.Epreuve, z.Groupe, z.LongueurEpreuve, z.NoBloc, z.ChiffreVague, z.Distance }).Distinct().ToList();
                System.Diagnostics.Debug.WriteLine("--------");
                System.Diagnostics.Debug.WriteLine(" t.ChiffreVague, t.Groupe, t.NoBloc");
                foreach (var t in b)
                {
                    System.Diagnostics.Debug.WriteLine(string.Format("{0},{1},{2}", t.ChiffreVague, t.Groupe, t.NoBloc));
                }
                foreach (var z in b.OrderBy(z => z.NoBloc).ThenBy(z => z.ChiffreVague))
                {
                    System.Diagnostics.Debug.WriteLine("--------");
                    System.Diagnostics.Debug.WriteLine(string.Format("{0},{1},{2}", z.ChiffreVague, z.Groupe, z.NoBloc));
                    ProgrammeCourse pc = new ProgrammeCourse();
                    EpreuveTrace    t  = Traces.SingleOrDefault(et => et.Epreuve == z.Distance);
                    if (t == null)
                    {
                        t         = new EpreuveTrace();
                        t.Epreuve = z.Distance;
                        t.Trace   = 100;
                        MessageBox.Show(string.Format("La distance {0} n'est pas configurée, on présume un tracé de 100 mètres", z.Distance));
                        Traces.Add(t);
                    }
                    //pc.Type == z.Epreuve;
                    pc.Bloc    = z.NoBloc;
                    pc.Epreuve = z.LongueurEpreuve.ToString();
                    pc.Trace   = t.Trace;

                    pc.NbTour = z.LongueurEpreuve / pc.Trace;
                    var         x            = laTotale2.Where(k => k.NoBloc == z.NoBloc && k.Epreuve == z.Epreuve && k.Groupe == z.Groupe && k.LongueurEpreuve == z.LongueurEpreuve);
                    int         nb           = x.Count();
                    string      min          = x.Min(k => k.LettreVague);
                    string      max          = x.Max(k => k.LettreVague);
                    ResultatObj r            = x.First();
                    string      chiffreSerie = r.NoVague.Replace(r.LettreVague, string.Empty);
                    int         serie        = System.Convert.ToInt32(chiffreSerie);
                    pc.Serie      = serie;
                    pc.LVagues    = x.Select(pz => pz.LettreVague).Distinct().ToList();
                    pc.De         = min;
                    pc.A          = max;
                    pc.TypeCourse = z.Epreuve;
                    programmes.Add(pc);

                    foreach (var v in x)
                    {
                        List <PatineurVague> patVags = null;
                        if (descVagues.ContainsKey(v.ChiffreVague))
                        {
                            patVags = descVagues[v.ChiffreVague];
                        }
                        else
                        {
                            patVags = new List <PatineurVague>();
                            descVagues.Add(v.ChiffreVague, patVags);
                        }
                        PatineurVague pv = new PatineurVague();
                        pv.Epreuve     = v.LongueurEpreuve;
                        pv.Groupe      = v.Groupe;
                        pv.Casque      = v.NoCasque;
                        pv.Patineurs   = v.Nom;
                        pv.Club        = v.Club;
                        pv.Rang        = v.Rang;
                        pv.Temps       = v.Temps.ToString();
                        pv.Points      = v.Point;
                        pv.Commentaire = string.Empty;
                        pv.Vague       = v.LettreVague;
                        //pv.Date;
                        patVags.Add(pv);
                    }
                }
            }
            else
            {
                // Non mixte, on se préocupe du sexe!
                var b = laTotale2.Select(z => new { z.Epreuve, z.Groupe, z.LongueurEpreuve, z.NoBloc, z.ChiffreVague, z.Distance, z.Sexe }).Distinct().ToList();
                System.Diagnostics.Debug.WriteLine("--------");
                System.Diagnostics.Debug.WriteLine(" t.ChiffreVague, t.Groupe, t.NoBloc, t.Sexe");
                foreach (var t in b)
                {
                    System.Diagnostics.Debug.WriteLine(string.Format("{0},{1},{2},{3}", t.ChiffreVague, t.Groupe, t.NoBloc, t.Sexe));
                }
                foreach (var z in b.OrderBy(z => z.NoBloc).ThenBy(z => z.ChiffreVague))
                {
                    System.Diagnostics.Debug.WriteLine("--------");
                    System.Diagnostics.Debug.WriteLine(string.Format("{0},{1},{2},{3}", z.ChiffreVague, z.Groupe, z.NoBloc, z.Sexe));
                    ProgrammeCourse pc = new ProgrammeCourse();
                    EpreuveTrace    t  = Traces.SingleOrDefault(et => et.Epreuve == z.Distance);
                    if (t == null)
                    {
                        t         = new EpreuveTrace();
                        t.Epreuve = z.Distance;
                        t.Trace   = 100;
                        MessageBox.Show(string.Format("La distance {0} n'est pas configurée, on présume un tracé de 100 mètres", z.Distance));
                        Traces.Add(t);
                    }
                    //pc.Type == z.Epreuve;
                    pc.Bloc    = z.NoBloc;
                    pc.Epreuve = z.LongueurEpreuve.ToString();
                    pc.Trace   = t.Trace;

                    pc.NbTour = z.LongueurEpreuve / pc.Trace;
                    var         x            = laTotale2.Where(k => k.NoBloc == z.NoBloc && k.Epreuve == z.Epreuve && k.Groupe == z.Groupe && k.LongueurEpreuve == z.LongueurEpreuve && z.Sexe == k.Sexe);
                    int         nb           = x.Count();
                    string      min          = x.Min(k => k.LettreVague);
                    string      max          = x.Max(k => k.LettreVague);
                    ResultatObj r            = x.First();
                    string      chiffreSerie = r.NoVague.Replace(r.LettreVague, string.Empty);
                    int         serie        = System.Convert.ToInt32(chiffreSerie);
                    pc.Serie      = serie;
                    pc.LVagues    = x.Select(pz => pz.LettreVague).Distinct().ToList();
                    pc.De         = min;
                    pc.A          = max;
                    pc.TypeCourse = z.Epreuve;
                    programmes.Add(pc);

                    foreach (var v in x)
                    {
                        List <PatineurVague> patVags = null;
                        if (descVagues.ContainsKey(v.ChiffreVague))
                        {
                            patVags = descVagues[v.ChiffreVague];
                        }
                        else
                        {
                            patVags = new List <PatineurVague>();
                            descVagues.Add(v.ChiffreVague, patVags);
                        }
                        PatineurVague pv = new PatineurVague();
                        pv.Epreuve     = v.LongueurEpreuve;
                        pv.Groupe      = v.Groupe;
                        pv.Casque      = v.NoCasque;
                        pv.Patineurs   = v.Nom;
                        pv.Club        = v.Club;
                        pv.Rang        = v.Rang;
                        pv.Temps       = v.Temps.ToString();
                        pv.Points      = v.Point;
                        pv.Commentaire = string.Empty;
                        pv.Vague       = v.LettreVague;
                        //pv.Date;
                        patVags.Add(pv);
                    }
                }
            }

            //pc.Serie = z.ChiffreVague;
            if (ParamCommuns.Instance.Programmes == null)
            {
                ParamCommuns.Instance.Programmes = programmes;
                ParamCommuns.Instance.DescVagues = descVagues;
                MiseAJourCompe();
            }
            else
            {
                // La compétition est déjà définie, on ajoute seulement les courses qui sont différentes
                List <ProgrammeCourse> actuel   = ParamCommuns.Instance.Programmes.ToList();
                List <ProgrammeCourse> nouveaux = programmes.ToList();
                foreach (ProgrammeCourse pc in actuel)
                {
                    ProgrammeCourse nouveau = nouveaux.SingleOrDefault(z => z.Bloc == pc.Bloc && z.Serie == pc.Serie);
                    if (nouveau != null &&
                        nouveau.Epreuve == pc.Epreuve &&
                        nouveau.NbTour == pc.NbTour &&
                        nouveau.Trace == pc.Trace &&
                        nouveau.TypeCourse == pc.TypeCourse &&
                        string.Join(",", nouveau.LVagues) == string.Join(",", pc.LVagues))
                    {
                        // pareil en tout point, pas un nouveau!
                        nouveaux.Remove(nouveau);
                    }
                    else
                    {
                        if (nouveau == null)
                        {
                            // On a un ancien qui n'existe plus (on l'elève du programme)
                            ParamCommuns.Instance.Programmes.Remove(pc);
                        }
                        else
                        {
                            // on a un ancien qui est différent d'un nouveau
                            ParamCommuns.Instance.Programmes.Add(nouveau);
                            ParamCommuns.Instance.Programmes.Remove(pc);
                        }
                    }
                }

                // On ajoute les vraix nouveaux
                nouveaux.ForEach(z => ParamCommuns.Instance.Programmes.Add(z));

                Dictionary <string, List <PatineurVague> > descVaguesActuel = new Dictionary <string, List <PatineurVague> >();
                foreach (KeyValuePair <string, List <PatineurVague> > kvp in ParamCommuns.Instance.DescVagues)
                {
                    descVaguesActuel.Add(kvp.Key, kvp.Value);
                }
                Dictionary <string, List <PatineurVague> > descVaguesNouveau = new Dictionary <string, List <PatineurVague> >();
                foreach (KeyValuePair <string, List <PatineurVague> > kvp in descVagues)
                {
                    descVaguesNouveau.Add(kvp.Key, kvp.Value);
                }
                foreach (string cle in descVaguesActuel.Keys)
                {
                    List <PatineurVague> pvactuels = descVaguesActuel[cle];

                    List <PatineurVague> pvnouveaux = null;
                    if (descVaguesNouveau.ContainsKey(cle))
                    {
                        pvnouveaux = descVaguesNouveau[cle];
                        descVaguesNouveau.Remove(cle);
                    }

                    bool tousPareil = true;
                    if (pvnouveaux != null && pvactuels.Count() == pvnouveaux.Count())
                    {
                        int i = 0;
                        foreach (PatineurVague pvactuel in pvactuels)
                        {
                            if (i < pvnouveaux.Count())
                            {
                                PatineurVague pvNouveau = pvnouveaux[i];
                                if (pvactuel.Patineurs == pvNouveau.Patineurs && pvactuel.Club == pvactuel.Club)
                                {
                                    pvactuel.Casque      = pvNouveau.Casque;
                                    pvactuel.Commentaire = pvNouveau.Commentaire;
                                    pvactuel.Date        = pvNouveau.Date;
                                    pvactuel.Epreuve     = pvNouveau.Epreuve;
                                    pvactuel.Groupe      = pvNouveau.Groupe;
                                    pvactuel.Points      = pvNouveau.Points;
                                    pvactuel.Rang        = pvNouveau.Rang;
                                    pvactuel.Temps       = pvNouveau.Temps;
                                    pvactuel.Vague       = pvNouveau.Vague;
                                }
                                else
                                {
                                    tousPareil = false;
                                    break;
                                }
                            }


                            i += 1;
                        }
                    }
                    else
                    {
                        tousPareil = false;
                    }

                    if (!tousPareil)
                    {
                        // Il y a une différence sur les patineurs
                        // il faut mettre à jour
                        ParamCommuns.Instance.DescVagues[cle].Clear();
                        pvnouveaux.ForEach(z => ParamCommuns.Instance.DescVagues[cle].Add(z));
                    }
                }

                foreach (string cle in descVaguesNouveau.Keys)
                {
                    ParamCommuns.Instance.DescVagues.Add(cle, descVaguesNouveau[cle]);
                }
            }
        }