/// <summary>
            /// méthode de conversion d'un ObjetObservable en Coderegime
            /// </summary>
            /// <param name="ObjetObservable"></param>
            /// <returns></returns>
            public static CodeRegime ConversionEnCodeRegime(CodeRegimeObservable ObjetObservable)
            {
                CodeRegime codeRegime = new CodeRegime();

                codeRegime.IDCodeRegime         = ObjetObservable.id;
                codeRegime.LIBELLE_CodeRegime   = ObjetObservable.libelle;
                codeRegime.COULEUR_CodeRegime   = ObjetObservable.couleur;
                codeRegime.SUPPRIMER_CodeRegime = ObjetObservable.supprimer;

                return(codeRegime);
            }
        /// <summary>
        /// constructeur
        /// </summary>
        public WPFCodeRegimeViewModel(IDialogService dialogService)
        {
            //déclaration du Dialog dans le constructeur
            _dialogService = dialogService;

            //*******************************************************************************************************************************************
            // GESTION DE LA PAGE WPFCodeRegime
            //*******************************************************************************************************************************************

            LoadedPage = new RelayCommand(() =>
            {
                ////////////////////////
                //  Gestion des Droits
                ////////////////////////
                CbxChecked = false;
                // vérification des droits
                using (ProgetEntities pg = new ProgetEntities())
                {
                    Droit droitUtilisateur = pg.Droits.Where(a => a.Matricule == ParamGlobaux.Matricule && a.IDEtablissement == ParamGlobaux.IDEtablissement &&
                                                             a.Fonctions == "Gestion des codes Régime").SingleOrDefault();
                    //On s'assure de ne pas avoir de "Null Pointer Exception"
                    if (droitUtilisateur != null && droitUtilisateur.Droit1 == "CT")
                    {
                        ControleDroit = true;
                    }
                    else
                    {
                        ControleDroit = false;
                    }
                }
                ChargementListView();
            });

            ////////////////////////////////////
            //  Gestion des boutons de WPFCaisse
            ////////////////////////////////////

            //------------------
            //  Bouton Quitter
            //------------------

            CodeRegimeQuitter = new RelayCommand <Window>(FermetureFenetre);

            //-----------------
            //  Bouton Ajouter
            //-----------------

            Ajouter = new RelayCommand(() =>
            {
                // instanciation d'un objet vide pour repartir de 0 pour le nouvel ajout
                ObsCodeRegime = new CodeRegimeObservable();
                checkCode     = true;
                // on met la couleur de fond du colorpicker à blanc
                couleurSelectionnee = Color.FromRgb(255, 255, 255);

                //on envoit vers la fenetre
                _dialogService.ShowDialog <WPFCodeRegimeAjouter>(this, this);
            });

            //------------------
            //  Evenement Modifier
            //------------------

            Modifier = new RelayCommand <CodeRegimeObservable>((item) =>
            {
                if (item != null)
                {
                    checkCode = false;
                    //on envoit vers la fenetre
                    _dialogService.ShowDialog <WPFCodeRegimeAjouter>(this, this);
                }
                else
                {
                    System.Windows.MessageBox.Show("aucune ligne selectionnée");
                }
            });

            //------------------
            //  Bouton Aide
            //------------------

            Aide = new RelayCommand(() =>
            {
                AffichageAide("AideAjouterGrandRegime.pdf");
            });



            //---------------------
            //  CheckBox Supprimer
            //---------------------

            CbxSupprimerListView = new RelayCommand <CodeRegimeObservable>((item) =>
            {
                // connexion à la base
                using (ProgetEntities pg = new ProgetEntities())
                {
                    // création d'un nouveau Code regime avec les données recueillies
                    CodeRegime codeRegime = pg.CodeRegimes.Where(a => a.IDCodeRegime == item.id).SingleOrDefault();

                    // recherche si ce Code est utilisée dans la table Usager
                    List <Usager> pu = pg.Usagers.Where(a => a.IDCodeRegime == codeRegime.IDCodeRegime).ToList();



                    if (pu.Count == 0)
                    {
                        // dans ce cas, ce Code n'existe pas dans la table PlanningUsager, il est dont totalement inutile et va donc être supprimé définitivement
                        pg.CodeRegimes.Remove(codeRegime);
                        pg.SaveChanges();
                    }
                    else
                    {
                        //on met à Code Régime la valeur de item.supprimer (objet porteur de la valeur changée)
                        codeRegime.SUPPRIMER_CodeRegime = item.supprimer;

                        //on sauvegarde les changements
                        pg.SaveChanges();
                    }
                    ChargementListView();
                }
            });


            //----------------------------
            //  CheckBox "Tous les Grands Régimes"
            //----------------------------

            CbkCodeRegime = new RelayCommand(() =>
            {
                using (ProgetEntities pg = new ProgetEntities())
                {
                    //création de la liste de Caisse qui va recevoir toutes les données de la requête Entity
                    List <CodeRegime> ListeCodes = pg.CodeRegimes.ToList();

                    // récupérons la liste générée par WPFCodeRegime
                    ObservableCollection <CodeRegime> ListViewListeRecup = new ObservableCollection <CodeRegime>(ListeCodes);

                    // on instancie la listViewList
                    ListViewListe = new ObservableCollection <CodeRegimeObservable>();

                    // parcourons la liste pour en extraire les éléments
                    foreach (CodeRegime item in ListViewListeRecup)
                    {
                        //on passe les données à la ListView
                        ListViewListe.Add(new CodeRegimeObservable(item.IDCodeRegime, item.LIBELLE_CodeRegime, item.COULEUR_CodeRegime, item.SUPPRIMER_CodeRegime));
                    }
                }
            });

            //gestion du Unchecked de la CheckBox "tous les codes régimes"
            CbkCodeRegimeUnchecked = new RelayCommand(() =>
            {
                ChargementListView();
            });


            //---------------------
            //  Bouton Supprimer
            //---------------------

            CMSupprimerListView = new RelayCommand <CodeRegimeObservable>((item) =>
            {
                if (item != null)
                {
                    // connexion à la base
                    using (ProgetEntities pg = new ProgetEntities())
                    {
                        // création d'un nouveau Code regime avec les données recueillies
                        CodeRegime codeRegime = pg.CodeRegimes.Where(a => a.IDCodeRegime == item.id).SingleOrDefault();

                        // recherche si ce Code est utilisée dans la table Usager
                        List <Usager> pu = pg.Usagers.Where(a => a.IDCodeRegime == codeRegime.IDCodeRegime).ToList();

                        if (pu.Count == 0)
                        {
                            // dans ce cas, ce Code n'existe pas dans la table PlanningUsager, il est dont totalement inutile et va donc être supprimé définitivement
                            pg.CodeRegimes.Remove(codeRegime);
                            pg.SaveChanges();
                        }
                        else
                        {
                            //on met à Code Régime la valeur de item.supprimer (objet porteur de la valeur changée)
                            codeRegime.SUPPRIMER_CodeRegime = !item.supprimer;

                            //on sauvegarde les changements
                            pg.SaveChanges();
                        }
                        ChargementListView();
                    }
                }
                else
                {
                    System.Windows.MessageBox.Show("aucune ligne selectionnée");
                }
            });

            //*******************************************************************************************************************************************
            // GESTION DE LA PAGE WPFCodeRegimeuAjouter
            //*******************************************************************************************************************************************

            ////////////////////////////////////////////////
            //  Gestion des boutons de WPFCodeRegimeAjouter
            ////////////////////////////////////////////////

            //------------------
            //  Bouton Quitter
            //------------------
            //Si aucune modification n'est en cours, ou on vient de valider notre ajout, on quitte directement
            //Autrement on affiche un message d'avertissement
            CodeRegimeAjouterQuitter = new RelayCommand <Window>((WPFCodeRegimeAjouter) =>
            {
                if (ObsCodeRegime.AllowExit)
                {
                    //Si notre booleen est vrai, pas de modif en attente
                    FermetureFenetre(WPFCodeRegimeAjouter);
                    //On ferme la page
                }
                else
                {
                    //Si notre booleen est faux, nous avons des nouvelles modifications
                    if (MessageBox.Show("Vous allez perdre vos modifications en cours", "Attention", MessageBoxButton.OKCancel) == MessageBoxResult.OK)
                    {
                        //Si l'utilisateur appuie sur "OK" la page est fermée
                        ObsCodeRegime.AllowExit = true;
                        FermetureFenetre(WPFCodeRegimeAjouter);

                        //Lorsque l'ont ferme la page on passe notre booleen a vrai
                    }
                }
            });



            //------------------------
            //  Bouton BtnCodeRegimeAjouter
            //------------------------

            CodeRegimeAjouterValider = new RelayCommand(() =>
            {
                try
                {
                    //on initialise l'accès à la base de donnée (Projet3Entities est le nom de la classe porteuse du dbcontxt dans Projet3BDD.Context.cs)
                    using (ProgetEntities pg = new ProgetEntities())
                    {
                        // recherche dans la BDD s'il existe déja une Caisse identique
                        CodeRegime existe = pg.CodeRegimes.Where(a => a.IDCodeRegime == ObsCodeRegime.id).SingleOrDefault();

                        // nous sommes en "Ajouter"
                        if (checkCode == true)
                        {
                            //Verification caractères spéciaux del'id
                            if (!Regex.IsMatch(ObsCodeRegime.id.ToString(), @"^[0-9]+$") == false)
                            {
                                //s'il n'existe pas d'objet en bas ayant la même id
                                if (existe == null)
                                {
                                    if (ObsCodeRegime.id == "" || ObsCodeRegime.libelle == "" || ObsCodeRegime.couleur == 0)
                                    {
                                        System.Windows.MessageBox.Show("Veuillez remplir l'ensemble des champs avec une étoile * ");
                                    }
                                    else if (!Regex.IsMatch(ObsCodeRegime.id.ToString(), @"^[a-zA-Z 0-9]+$") == true || !Regex.IsMatch(ObsCodeRegime.libelle.ToString(), @"^[a-zA-Z 0-9]+$") == true)
                                    {
                                        System.Windows.MessageBox.Show("caractère spéciaux interdits (lettres et chiffres uniquement)");
                                    }
                                    // on insère la Caisse dans la BDD
                                    else if (ObsCodeRegime.id != "" && ObsCodeRegime.libelle != "" && ObsCodeRegime.couleur != 0 && !Regex.IsMatch(ObsCodeRegime.libelle.ToString(), @"^[a-zA-Z 0-9]+$") == false)
                                    {
                                        pg.CodeRegimes.Add(CodeRegimeObservable.ConversionEnCodeRegime(ObsCodeRegime));

                                        // on sauvegarde les changements dans la BDD
                                        pg.SaveChanges();
                                        val = false;

                                        //on met à jour la listeView
                                        ListViewListe.Add(ObsCodeRegime);
                                        System.Windows.MessageBox.Show("Nouveau Grand Regime Ajouté");
                                        ObsCodeRegime.AllowExit = true;
                                    }
                                }
                                else
                                {
                                    System.Windows.MessageBox.Show("Il existe déja une Caisse portant ce code");
                                }
                            }
                            else
                            {
                                System.Windows.MessageBox.Show("Chiffres uniquement");
                            }
                        }

                        // nous sommes en "Modifier"
                        if (checkCode == false)
                        {
                            //Debug.WriteLine( ObsCodeRegime.libelle.ToString() );
                            //Debug.WriteLine( !Regex.IsMatch( ObsCodeRegime.libelle.ToString(), @"^[a-zA-Z 0-9]+$" ) );

                            // si libellé n'est pas vide et que couleur n'est pas égale à 0
                            if (ObsCodeRegime.libelle == "" || ObsCodeRegime.couleur == 0)
                            {
                                System.Windows.MessageBox.Show("Veuillez remplir l'ensemble des champs avec une étoile * ");
                            }
                            else if (!Regex.IsMatch(ObsCodeRegime.libelle.ToString(), @"^[a-zA-Z 0-9]+$") == true)
                            {
                                System.Windows.MessageBox.Show("caractère spéciaux interdits (lettres et chiffres uniquement)");
                            }
                            else if (ObsCodeRegime.libelle != "" && ObsCodeRegime.couleur != 0 && !Regex.IsMatch(ObsCodeRegime.libelle.ToString(), @"^[a-zA-Z 0-9]+$") == false)
                            {
                                existe.LIBELLE_CodeRegime = ObsCodeRegime.libelle;
                                existe.COULEUR_CodeRegime = ObsCodeRegime.couleur;

                                pg.SaveChanges();
                                ObsCodeRegime.AllowExit = true;
                                val = false;

                                System.Windows.MessageBox.Show("Modifications enregistrées");
                            }
                        }
                    }
                }
                catch (DbEntityValidationException e)
                {
                    foreach (var eve in e.EntityValidationErrors)
                    {
                        Debug.WriteLine("DEBUG :Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
                                        eve.Entry.Entity.GetType().Name, eve.Entry.State);
                        foreach (var ve in eve.ValidationErrors)
                        {
                            Debug.WriteLine(" DEBUG:- Property: \"{0}\", Error: \"{1}\"",
                                            ve.PropertyName, ve.ErrorMessage);
                        }
                    }
                }
            });

            // commande gérant la reception du changement de couleur de WPFCodeRegimeAjouter
            couleurChange = new RelayCommand(() =>
            {
                ObsCodeRegime.couleur = ColorToBase(couleurSelectionnee);
            });
        }