private Visite TryCreateVisite(VisiteImport monImport, int cleUtilisateur, List<Pp> pps, List<EqEquipement> eqs)
        {
            try
            {
                Visite maVisite = new Visite();

                if (monImport.TypeEquipement == "PP" && !monImport.IsPPModifed)
                {
                    Pp newpp = pps.FirstOrDefault<Pp>(pp => pp.ClePp == monImport.CleEquipement);
                    newpp.Visites.Add(maVisite);
                }
                else if (!monImport.IsEquipementTempo && monImport.TypeEquipement != "PP")
                {
                    EqEquipement neweq = eqs.FirstOrDefault<EqEquipement>(eq => eq.CleEquipement == monImport.CleEquipement);
                    neweq.Visites.Add(maVisite);
                }

                // champs obligatoire
                if (monImport.Utilisateur != null)
                {
                    maVisite.UsrUtilisateur2 = monImport.Utilisateur;
                }
                else
                {
                    maVisite.CleUtilisateurMesure = monImport.CleUtilisateur;
                }

                maVisite.EstValidee = monImport.EstValide;
                maVisite.Telemesure = monImport.IsTelemesure;

                // Dates
                maVisite.DateVisite = monImport.DateVisite;
                maVisite.DateImport = monImport.DateImport;
                maVisite.DateSaisie = monImport.DateSaisie;

                // Spec import
                maVisite.CleUtilisateurImport = cleUtilisateur;
                maVisite.CleUtilisateurCreation = monImport.CleUtilisateur;
                maVisite.Commentaire = monImport.CommentaireVisite;

                var firstOrDefault = this.ObjectContext.RefEnumValeur.FirstOrDefault(c => c.CodeGroupe == "TYPE_EVAL" && c.LibelleCourt == "EG");
                if (firstOrDefault != null)
                {
                    maVisite.EnumTypeEval = firstOrDefault.CleEnumValeur;
                }
                maVisite.EnumTypeEvalComposition = monImport.EnumTypeEvalComposition;

                return maVisite;
            }
            catch (Exception ex)
            {
                monImport.AddOnError(string.Format("Erreur lors de l'ajout de la visite : {0}", ex.Message));
                return null;
            }
        }
 private bool TryCreateMesures(VisiteImport monImport, Visite maVisite, List<RefEnumValeur> refEnumValeurs)
 {
     try
     {
         if (monImport.TypeEquipement == "PP")
         {
             // Vérification que la Pp visitée dispose d'un temoin enterré amovible
             if (maVisite.ClePp.HasValue && maVisite.Pp != null && maVisite.Pp.PresenceDUneTelemesure)
             {
                 if (!TryCreateListMesures(monImport, maVisite, refEnumValeurs))
                 {
                     return false;
                 }
             }
             else
             {
                 monImport.AddOnError("Erreur lors de la création des mesures : type de PP non pris en charge par la télémesure");
                 return false;
             }
         }
         else
         {
             if (maVisite.CleEquipement.HasValue && maVisite.EqEquipement != null)
             {
                 var prop = maVisite.EqEquipement.GetType().GetProperty("PresenceTelemesure");
                 if (prop != null && (bool)prop.GetValue(maVisite.EqEquipement, null))
                 {
                     if (!TryCreateListMesures(monImport, maVisite, refEnumValeurs))
                     {
                         return false;
                     }
                 }
                 else
                 {
                     monImport.AddOnError("Erreur lors de la création des mesures : équipement non télémesuré");
                     return false;
                 }
             }
         }
         maVisite.RelevePartiel = true;
         return true;
     }
     catch (Exception ex)
     {
         monImport.AddOnError(string.Format("Erreur lors de la création des mesures : {0}", ex.Message));
         return false;
     }
 }
        private bool TryCreateAlertes(VisiteImport monImport, Visite maVisite, List<RefEnumValeur> refEnumValeurs)
        {
            try
            {
                // On sélectionne uniquement les mesures qui sont en dépassement de seuil
                foreach (MesMesure mamesure in maVisite.MesMesure.Where(a => a.IsDepassementSeuil))
                {
                    // création de l'alerte de type seuil
                    mamesure.Alertes.Add(new Alerte()
                    {
                        RefEnumValeur = refEnumValeurs.FirstOrDefault(c => c.CodeGroupe == "ENUM_TYPE_ALERTE" && c.Valeur == "S"),
                        Date = monImport.DateSaisie,
                        Supprime = false
                    });

                    maVisite.Alertes.Add(mamesure.Alertes.FirstOrDefault());
                }

                return true;
            }
            catch (Exception ex)
            {
                monImport.AddOnError(string.Format("Erreur lors de la création des alertes : {0}", ex.Message));
                return false;
            }
        }
        private List<VisiteImport> importerLesLignes(int cleUtilisateur, ObservableCollection<String> lines)
        {
            List<VisiteImport> VisitesImport = new List<VisiteImport>();
            List<String[]> rowTable = rowsToRowTable(lines);

            // Chargement des données
            UsrUtilisateur userTelemesure = GetUsrUtilisateurByIdentifiant("USR_TLM");
            UsrUtilisateur userImport = GetUsrUtilisateurByCle(cleUtilisateur);

            List<RefEnumValeur> refEnumValeurs = this.ObjectContext.RefEnumValeur.ToList();
            List<MesClassementMesure> mesClassementMesures = GetMesClassementMesureWithMesNiveauProtection().ToList();

            int index = 0;
            string nomFichier = String.Empty;

            // 1ère itération pour valider le type d'équipement
            foreach (String[] row in rowTable)
            {
                VisiteImport MonImport = new VisiteImport() { };
                VisitesImport.Add(MonImport);
                MonImport.NomFichier = row.ElementAt(row.Count() - 2);
                if (MonImport.NomFichier != nomFichier)
                {
                    nomFichier = MonImport.NomFichier;
                    index = 0;
                }
                MonImport.IndexOnFile = ++index;
                MonImport.Line = row.LastOrDefault();
                MonImport.Row = row;

                try
                {
                    MonImport.TypeEquipementOrigine = row[1];

                    // Champs VISITES
                    MonImport.CleEquipement = Int32.Parse(row[0]);
                    MonImport.CleUtilisateur = userTelemesure.CleUtilisateur;
                    MonImport.DateImport = DateTime.Now;

                    MonImport.IsTelemesure = true;
                    MonImport.EstValide = true;
                    MonImport.CommentaireVisite = row[40];
                    MonImport.TypeEquipement = refEnumValeurs.Where(c => c.CodeGroupe == "IMPORT_TELEMESURE" && c.Libelle == "TypeEquipement" && c.Valeur.ToUpper() == row[1].ToUpper())
                        .Select(c => c.LibelleCourt).FirstOrDefault();
                    var firstOrDefault = refEnumValeurs.FirstOrDefault(c => c.CodeGroupe == "TYPE_EVAL" && c.LibelleCourt == "EG");
                    if (firstOrDefault != null)
                    {
                        MonImport.EnumTypeEval = firstOrDefault.CleEnumValeur;
                    }
                    MonImport.EnumTypeEvalComposition = MonImport.EnumTypeEval;
                }
                catch (IndexOutOfRangeException)
                {
                    MonImport.AddOnError(string.Format("Le format de la ligne {0} est incorrect.", index));
                }
                catch (Exception ex)
                {
                    MonImport.AddOnError(string.Format("Format de la ligne {0} incorrect : {1}", index, ex.Message));
                }

                try
                {
                    MonImport.DateVisite = DateTime.Parse(row[3], new CultureInfo("fr-FR"));
                    MonImport.DateSaisie = MonImport.DateVisite;
                }
                catch
                {
                    MonImport.AddOnError("Date de la mesure invalide.");
                }

                if (!MonImport.IsOnError && MonImport.TypeEquipement == null)
                {
                    MonImport.AddOnError("Le type d'équipement ne correspond à aucun type connu");
                }
            }

            List<EqEquipement> eqEquipements = FindEqEquipementsByListCle(new ObservableCollection<int>(VisitesImport.Where(vi => vi.TypeEquipement != "PP").Select(vi => vi.CleEquipement).Distinct())).ToList();
            List<Pp> pps = FindPpsByListCle(new ObservableCollection<int>((VisitesImport.Where(vi => vi.TypeEquipement == "PP").Select(vi => vi.CleEquipement).Union(eqEquipements.Select(e => e.ClePp))).Distinct())).ToList();

            foreach (VisiteImport vi in VisitesImport)
            {
                vi.VisiteRapport.NumLigne = vi.IndexOnFile;
                vi.VisiteRapport.NomFichier = vi.NomFichier;
                vi.VisiteRapport.TypeEquipement = vi.TypeEquipement;
                vi.VisiteRapport.CleEquipement = vi.CleEquipement;
                vi.VisiteRapport.DateVisite = vi.DateVisite;
                vi.VisiteRapport.TextImport = vi.TextImport;

                //Contrôle de l'intégrité des équipements
                Pp pp = pps.FirstOrDefault(p => p.ClePp == vi.CleEquipement);
                EqEquipement eq = eqEquipements.FirstOrDefault(e => e.CleEquipement == vi.CleEquipement);
                if (vi.TypeEquipement == "PP" && pp != null)
                {
                    vi.VisiteRapport.LibelleEq = pp.Libelle;
                }
                else if (eq != null)
                {
                    vi.VisiteRapport.LibelleEq = eq.Libelle;

                    if (eq.TypeEquipement.CodeEquipement != vi.TypeEquipement)
                    {
                        vi.AddOnError("la clé d'équipement et le type ne correspondent pas");
                    }
                }
                else
                {
                    vi.AddOnError("La clé équipement ne correspond à aucun équipement connu");
                }
            }

            foreach (VisiteImport vi in VisitesImport)
            {
                AjouterLigne(vi, cleUtilisateur, refEnumValeurs, mesClassementMesures, pps, eqEquipements);
            }

            return VisitesImport;
        }
        private void AjouterLigne(VisiteImport monImport, int cleUtilisateur, List<RefEnumValeur> refEnumValeurs, List<MesClassementMesure> mesClassementMesures, List<Pp> pps, List<EqEquipement> equipements)
        {
            if (!monImport.IsOnError)
            {
                // Création de la visite
                Visite nouvelleVisite = TryCreateVisite(monImport, cleUtilisateur, pps, equipements);
                // Remplissage de la visite avec les propriétés disponibles dans le VisiteImport
                if (nouvelleVisite != null)
                {
                    bool VisitIsValid = false;
                    // et traitement des mesures
                    if (TryCreateMesures(monImport, nouvelleVisite, refEnumValeurs))
                    {
                        // Création des alertes
                        if (TryCreateAlertes(monImport, nouvelleVisite, refEnumValeurs))
                        {
                            // On ajoute la visite avec ses mesures dans le contexte
                            this.ObjectContext.Visites.AddObject(nouvelleVisite);
                            this.CreateVisitesForPpJumelees(nouvelleVisite);

                            try
                            {

                                this.ObjectContext.SaveChanges();
                                VisitIsValid = true;
                                monImport.AddOnSucess();
                            }
                            catch
                            {
                                monImport.AddOnError("Erreur lors de l'enregistrement, réessayez ultérieurement ou contactez votre administrateur");
                            }
                        }
                    }
                    if (!VisitIsValid)//la visite doit être retiré du context
                    {
                        if (monImport.TypeEquipement == "PP")
                        {
                            var newpp = pps.Single(pp => pp.ClePp == monImport.CleEquipement);
                            newpp.Visites.Remove(nouvelleVisite);
                            this.ObjectContext.SaveChanges();
                        }
                        else
                        {
                            var newpp = equipements.Single(eq => eq.CleEquipement == monImport.CleEquipement);
                            newpp.Visites.Remove(nouvelleVisite);
                            this.ObjectContext.SaveChanges();
                        }

                    }
                }
                //la visite n'a pas pu etre créée
            }
        }
 /// <summary>
 /// MANTIS 10882 FSI 23/06/2014 : Import télémesure V3
 /// Recherche les Enums d'attribution de CleTypeMesure en base et attribution de mesures en fonction 
 /// </summary>
 /// <param name="monImport">ImportVisite en cours d'import</param>
 /// <param name="maVisite">Visite en cours de création</param>
 /// <param name="refEnumValeurs">RefEnumValeurs chargés depuis la base</param>
 /// <returns>Si une erreur apparaît, arrêt du traitement et renvoit false sinon true</returns>
 private static bool TryCreateListMesures(VisiteImport monImport, Visite maVisite, List<RefEnumValeur> refEnumValeurs)
 {
     foreach (RefEnumValeur typeMesure in refEnumValeurs.Where(c => c.CodeGroupe == "IMPORT_TELEMESURE_TYPEMESURE" && c.Libelle == monImport.TypeEquipement))
     {
         if (!String.IsNullOrEmpty(monImport.Row[typeMesure.NumeroOrdre - 1]))
         {
             decimal valeur;
             if (decimal.TryParse(monImport.Row[typeMesure.NumeroOrdre - 1], out valeur))
             {
                 int cleTypeMesure;
                 if (!String.IsNullOrEmpty(typeMesure.Valeur)
                     && int.TryParse(typeMesure.Valeur, out cleTypeMesure))
                 {
                     maVisite.MesMesure.Add(new MesMesure()
                     {
                         Valeur = valeur,
                         CleTypeMesure = cleTypeMesure
                     });
                 }
             }
             else
             {
                 monImport.AddOnError("Erreur lors de la création des mesures : valeur de la mesure invalide");
                 return false;
             }
         }
     }
     return true;
 }