public override ValidationResult Validate()
 {
     //Enregistrer
     if (TachesProdAjoutees.Count == 0)
     {
         return(new ValidationResult(true));
     }
     else
     {
         DALTache.EnregistrerTachesProd(TachesProdAjoutees.ToList());
         return(new ValidationResult(true));
     }
 }
Exemple #2
0
        public void TestMethod1()
        {
            List <Personne> _personnes = DALTache.RecupererPersonnesTaches("GENOMICA");
            var             p          = _personnes.Where(x => x.CodePersonne == "RBEAUMONT").FirstOrDefault();

            Assert.AreEqual(9, p.TachesProd.Count());

//            Récupérer la valeur du test avec la requête suivante
//                select*
//from jo.Tache T
//inner join jo.TacheProd TP on TP.IdTache = T.IdTache
//where Annexe = 0 and Login = '******' and NumeroVersion = 1
        }
Exemple #3
0
        /// <summary>
        /// Charge la liste des personnes et tâches en brut pour le logiciel la version sélectionnés
        /// </summary>
        private void Charger(object obj)
        {
            LogicielCourant = (Logiciel)CollectionViewSource.GetDefaultView(Logiciels).CurrentItem;
            VersionCourante = (Entity.Version)CollectionViewSource.GetDefaultView(LogicielCourant.Versions).CurrentItem;
            var t = new ObservableCollection <TacheApercu>(DALTache.RecupererTachesApercu(LogicielCourant.CodeLogiciel,
                                                                                          VersionCourante.NumVersion, _userCourant));

            //Chargement du DataContext
            TachesApercu.Clear();
            foreach (var a in t)
            {
                TachesApercu.Add(a);
            }
        }
        /// <summary>
        /// Ajoute ou supprime des tâches annexes dans la base de données
        /// </summary>
        /// <param name="obj"></param>
        private void EnregistrerTachesAnnexes(object obj)
        {
            // On récupère l'employé courant
            var empCourant = (Personne)CollectionViewSource.GetDefaultView(Personnes).CurrentItem;

            // Liste des tâches annexes de départ (soit avant toute modification)
            var listPers = DALTache.RecupererPersonnesTachesAnnexes(_usercourant);

            DALTache.RecupererPersonnesTachesAnnexesEtendues(listPers);
            var listTachesDépart = listPers.Where(p => p.CodePersonne == empCourant.CodePersonne).FirstOrDefault().TachesAnnexes;

            // On compare la liste actuelle des tâches annexes de l'employé à celle de départ
            // Cela permet de détecter les changements effectués par l'utilisateur.
            foreach (var t in empCourant.TachesAnnexes)
            {
                // Assignation de départ de la tâche annexes courante
                var assignationDépart = listTachesDépart.Where(a => a.CodeActivite == t.CodeActivite).FirstOrDefault().Assignation;

                // On ajoute ou supprime une tâche annexe si l'assignation associée change de valeur
                if (t.Assignation != assignationDépart)
                {
                    if (t.Assignation)
                    {
                        try
                        {
                            DALTache.AjouterTacheAnnexe(empCourant.CodePersonne, t);                        // Ajout
                        }
                        catch (Exception ex)
                        {
                            MessageBox.Show(ex.Message, "Erreur");
                        }
                    }
                    else
                    {
                        try
                        {
                            DALTache.SupprimerTacheAnnexe(empCourant.CodePersonne, t.CodeActivite);         // Suppression
                        }
                        catch (Exception ex)
                        {
                            MessageBox.Show(ex.Message, "Erreur");
                        }
                    }
                }
            }
        }
        public VMTachesAnnexes()
        {
            // Récupération du statut manager de la personne connecté
            // True = la personne connectée est manager
            StatutManager = Properties.Settings.Default.Manager;

            // Récupération du code de l'utilisateur courant
            _usercourant = Properties.Settings.Default.CodeDernierUtilisateur;

            // Récupération de la liste des personnes avec leurs tâches annexes
            _listPers = DALTache.RecupererPersonnesTachesAnnexes(_usercourant);

            // Récupération de la liste des personnes avec leurs tâches annexes étendues
            // On se sert du booléen Assignation pour savoir si l'activité annexe est affectée ou non à l'employé
            DALTache.RecupererPersonnesTachesAnnexesEtendues(_listPers);

            Personnes = new ObservableCollection <Personne>(_listPers);
        }
        //Suppression de la tâche sélectionnée
        private void SupprimerTache(object o)
        {
            if (PersonneCourante == null)
            {
                return;
            }
            TacheProd t = (TacheProd)CollectionViewSource.GetDefaultView(PersonneCourante.TachesProd).CurrentItem;

            try
            {
                if (t == null)
                {
                    return;
                }
                DALTache.SupprimerTacheProd(t.IdTache);
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message
                                + "\n" + "", "Attention", MessageBoxButton.OK);
            }
        }
Exemple #7
0
        /// <summary>
        /// Exportation au format xml
        /// </summary>
        /// <param name="obj">Paramètre de la commande</param>
        private void Exporter(object obj)
        {
            LogicielCourant = (Logiciel)CollectionViewSource.GetDefaultView(Logiciels).CurrentItem;
            VersionCourante = (Entity.Version)CollectionViewSource.GetDefaultView(LogicielCourant.Versions).CurrentItem;
            PersonnesTaches = DALTache.RecupererPersonnesTaches(_userCourant);

            foreach (var b in PersonnesTaches)
            {
                // Si la personne en cours (b) à des taches de production associées
                if (b.TachesProd != null)
                {
                    var p = b.TachesProd.Where(x => (x.CodeVersion == VersionCourante.NumVersion) &&
                                               (x.CodeLogiciel == LogicielCourant.CodeLogiciel)).ToList();
                    b.TachesProd = new ObservableCollection <Entity.TacheProd>(p);
                }
            }

            // Ouverture de la fenètre pour choisir le chemin d'accès au fichier exporté
            SaveFileDialog dos = new SaveFileDialog();

            dos.Filter       = "XML Files (*.xml)|*.xml";
            dos.DefaultExt   = "xml";
            dos.AddExtension = true;
            if (dos.ShowDialog() == DialogResult.OK && !string.IsNullOrWhiteSpace(dos.FileName))
            {
                DALEchange.ExporterXML(PersonnesTaches, dos.FileName);
            }

            #region TestProgressBar

            var dlg = new ModalWindow(new VMProgressBar());
            dlg.Title = "Progression de l'export";
            bool?res = dlg.ShowDialog();

            #endregion
        }
 public VMSaisieTemps(ObservableCollection <Logiciel> LogicielsVMMain)
 {
     Utilisateur = (DALTache.RecupererPersonnesTaches(
                        Properties.Settings.Default.CodeDernierUtilisateur)).FirstOrDefault();
     Logiciels = LogicielsVMMain;
 }