private void ImporterFichier()
    {
        DateTime dateDebutAnalyse = DateTime.Now;

        if (User.IsInRole("Administrateur") && MemberInfoData == null)
        {
            MessageAnalyse = "Désolé Admin, sélectionnez un Membre pour importer des données.";
            EventFinImport.Set();
            FinTraitement = true;
            return;
        }

        if (DocumentNom.PostedFile.FileName == "")
        {
            MessageAnalyse = "Choisissez un fichier à importer. ";
            EventFinImport.Set();
            FinTraitement = true;
            return;
        }

        if (CheckBoxImportVotes.Checked && CheckBoxImportInterviewes.Checked == false)
        {
            CheckBoxExportIntervieves.Checked = true;
            MessageAnalyse = "Vous ne pouvez pas importer les votes sans exporter les interviewés. ";
            EventFinImport.Set();
            FinTraitement = true;
            return;
        }

        HttpPostedFile file = DocumentNom.PostedFile;
        int            size = file.ContentLength;

        if (size <= 0)
        {
            MessageAnalyse = "Un problème est survenu avec le téléchargement du fichier sur le serveur, le fichier n'est pas disponible. ";
            EventFinImport.Set();
            FinTraitement = true;
            return;
        }

        String virtualPath = "~/MemberDataFiles/";
        string filePath    = virtualPath;

        virtualPath += Path.GetFileName(DocumentNom.PostedFile.FileName);
        String physicalDir  = Server.MapPath(filePath);
        String physicalPath = Server.MapPath(virtualPath);

        // Sauver le fichier
        try
        {
            int tailleMax = 10 * 1024 * 1024; // 10 Mo
            if (DocumentNom.PostedFile.ContentLength >= tailleMax)
            {
                MessageAnalyse += "Error taille du fichier : " + Tools.FileSizeFormat(DocumentNom.PostedFile.ContentLength, "N");
                MessageAnalyse += " supérieure à la taille maximum : " + Tools.FileSizeFormat(tailleMax, "N");
                EventFinImport.Set();
                FinTraitement = true;
                return;
            }
            DocumentNom.PostedFile.SaveAs(physicalPath);
        }
        catch (Exception ex)
        {
            MessageAnalyse += ex.Message;
            EventFinImport.Set();
            FinTraitement = true;
            return;
        }

        DataSet dataSet = new DataSet();

        try
        {
            XmlReader xmlr = XmlReader.Create(physicalPath);
            dataSet.ReadXml(xmlr);
            xmlr.Close();
        }
        catch
        {
            MessageAnalyse += "Fichier non valide. ";
            File.Delete(physicalPath);
            EventFinImport.Set();
            FinTraitement = true;
            return;
        }

        // Dans le cadre d'un Tread on ne peut pas utiliser SessionState
        Limitation limitations = new Limitation(MemberInfoData.MembreGUID);

        //
        // Creer les Questionnaires
        //
        foreach (DataTable dt in dataSet.Tables)
        {
            if (dt.TableName.Contains("Questionnaire"))
            {
                // Tester les limitations avant d'ajouter le questionnaire
                if (limitations.LimiteQuestionnaires)
                {
                    MessageAnalyse += "La limite du nombre de Questionnaires : " + limitations.NombreQuestionnaires + " est atteinte.";
                    File.Delete(physicalPath);
                    EventFinImport.Set();
                    FinTraitement = true;
                    return;
                }

                Questionnaire questionnaire      = Questionnaire.FillFromXML(dt.Rows[0]);
                int           oldQuestionnaireID = questionnaire.QuestionnaireID;
                string        oldCodeAcces       = questionnaire.CodeAcces.ToString();

                questionnaire.MembreGUID   = MemberInfoData.MembreGUID;
                questionnaire.DateCreation = DateTime.Now; // Modifier la date de creation a maintenant

                ArrayList codes     = QuestionnaireDAL.GetCodeAccessAll();
                string    codeAcces = Tools.CalculCodeAcces(MemberInfoData.MembreID, codes).ToString();
                questionnaire.CodeAcces = int.Parse(codeAcces);

                int status = Questionnaire.Create(questionnaire);
                if (status == 1)
                {
                    MessageAnalyse += "Questionnaire : " + questionnaire.Description + " créé correctement.<br/>";
                    limitations.AjouterQuestionnaire();
                }
                else if (status == 2)
                {
                    MessageAnalyse += "Le Questionnaire : " + questionnaire.Description + " existe déjà.<br>";
                    File.Delete(physicalPath);
                    EventFinImport.Set();
                    FinTraitement = true;
                    return;
                }
                else
                {
                    MessageAnalyse += "Erreur sur la création du Questionnaire : " + questionnaire.Description + " <br/>";
                    File.Delete(physicalPath);
                    EventFinImport.Set();
                    FinTraitement = true;
                    return;
                }

                //
                // Tagger les Objets du Questionnaire avec le nouvel ID
                //
                int    newQuestionnaireID = questionnaire.QuestionnaireID;
                string newCodeAcces       = codeAcces;

                // Questions
                TaggerObjet(ref dataSet, "QQuestion", "QuestionnaireID", oldQuestionnaireID.ToString(), newQuestionnaireID.ToString());

                // Interviewe
                TaggerObjet(ref dataSet, "Personne", "QuestionnaireID", oldQuestionnaireID.ToString(), newQuestionnaireID.ToString());
                TaggerObjet(ref dataSet, "Personne", "PersonneCode", oldCodeAcces, newCodeAcces);

                // Votes
                TaggerObjet(ref dataSet, "Vote", "QuestionnaireID", oldQuestionnaireID.ToString(), newQuestionnaireID.ToString());

                // Score
                TaggerObjet(ref dataSet, "Score", "ScoreQuestionnaireID", oldQuestionnaireID.ToString(), newQuestionnaireID.ToString());
            }
            if (dt.TableName.Contains("QQuestion"))
            {
                // On passe aux Questions
                break;
            }
        }

        //
        // Creer les Questions
        //
        int nbQuestions = 0;

        foreach (DataTable dt in dataSet.Tables)
        {
            if (dt.TableName.Contains("QQuestion"))
            {
                // Tester les limitations avant d'ajouter la question
                if (limitations.LimiteQuestions)
                {
                    MessageAnalyse += "La limite du nombre de Questions : " + limitations.NombreQuestions + " est atteinte.";
                    File.Delete(physicalPath);
                    EventFinImport.Set();
                    FinTraitement = true;
                    return;
                }

                PollQuestion question      = PollQuestion.FillFromXML(dt.Rows[0]);
                string       oldQuestionID = question.PollQuestionId.ToString();
                question.MembreGUID = MemberInfoData.MembreGUID;
                int status = PollQuestion.Create(question);
                if (status != 0)
                {
                    MessageAnalyse += "Erreur à la création de la Question : " + question.Question + "<br/>";
                    File.Delete(physicalPath);
                    EventFinImport.Set();
                    FinTraitement = true;
                    return;
                }
                else
                {
                    nbQuestions += 1;
                    limitations.AjouterQuestion();
                }

                //
                // Tagger les Objets de la Question avec le nouvel ID
                //
                string newQuestionID = question.PollQuestionId.ToString();

                // Reponse
                TaggerObjet(ref dataSet, "Reponse", "PollQuestionId", oldQuestionID, newQuestionID);

                // Votes
                TaggerObjet(ref dataSet, "Vote", "PollQuestionId", oldQuestionID, newQuestionID);
            }
            if (dt.TableName.Contains("Reponse"))
            {
                // On passe aux Reponses
                break;
            }
        }
        MessageAnalyse += "Question créées : " + nbQuestions.ToString() + "<br/>";

        int nbReponses = 0;

        foreach (DataTable dt in dataSet.Tables)
        {
            if (dt.TableName.Contains("Reponse"))
            {
                PollAnswer reponse         = PollAnswer.FillFromXML(dt.Rows[0]);
                string     oldPollAnswerID = reponse.PollAnswerId.ToString();
                int        status          = PollAnswer.Create(reponse);
                if (status == 0)
                {
                    nbReponses += 1;
                }
                else
                {
                    MessageAnalyse += "Erreur à la création de la réponse : " + reponse.Answer;
                    File.Delete(physicalPath);
                    EventFinImport.Set();
                    FinTraitement = true;
                    return;
                }

                //
                // Tagger les Objets de la Reponse avec le nouvel ID
                //
                string newPollAnswerID = reponse.PollAnswerId.ToString();

                // Votes
                TaggerObjet(ref dataSet, "Vote", "PollAnswerId", oldPollAnswerID, newPollAnswerID);
            }
            if (dt.TableName.Contains("Personne"))
            {
                break;
            }
        }
        MessageAnalyse += "Réponses créés : " + nbReponses.ToString() + "<br/>";

        int nbInterviewes = 0;

        if (CheckBoxImportInterviewes.Checked)
        {
            foreach (DataTable dt in dataSet.Tables)
            {
                if (dt.TableName.Contains("Personne"))
                {
                    string   message         = "";
                    Personne personne        = Personne.FillFromXML(dt.Rows[0]);
                    string   oldPersonneGUID = personne.PersonneGUID.ToString();

                    // Trouver si l'utilisateur de ce questionnaire est limite
                    if (limitations.LimitesInterviewes)
                    {
                        MessageAnalyse += "La limite du nombre d'Interviewés : " + limitations.NombreInterviewes + " est atteinte.";
                        File.Delete(physicalPath);
                        EventFinImport.Set();
                        FinTraitement = true;
                        return;
                    }

                    int retCode = Personne.Create(personne, true, ref message);
                    if (retCode == 1)
                    {
                        nbInterviewes += 1;
                        limitations.AjouterInterviewes(1);
                    }
                    else
                    {
                        MessageAnalyse += message;
                        File.Delete(physicalPath);
                        EventFinImport.Set();
                        FinTraitement = true;
                        return;
                    }

                    //
                    // Tagger les Objets de la Reponse avec le nouvel ID
                    //
                    string newPersonneGUID = personne.PersonneGUID.ToString();

                    // Votes
                    TaggerObjet(ref dataSet, "Vote", "UserGUID", oldPersonneGUID, newPersonneGUID);
                }
                if (dt.TableName.Contains("Vote"))
                {
                    break;
                }
            }
        }
        MessageAnalyse += "Interviewés créés : " + nbInterviewes.ToString() + "<br/>";

        int nbVotes = 0;

        if (CheckBoxImportVotes.Checked)
        {
            foreach (DataTable dt in dataSet.Tables)
            {
                if (dt.TableName.Contains("Vote"))
                {
                    PollVote vote = PollVote.FillFromXML(dt.Rows[0]);

                    int status = PollVote.Create(vote);
                    if (status == 2)
                    {
                        MessageAnalyse += "Vote existe déjà";
                        File.Delete(physicalPath);
                        EventFinImport.Set();
                        FinTraitement = true;
                        return;
                    }
                    else
                    {
                        nbVotes += 1;
                    }
                }
                if (dt.TableName.Contains("Score"))
                {
                    break;
                }
            }

            if (limitations.LimitesReponses)
            {
                MessageAnalyse += "La limite du nombre de Réponses : " + limitations.NombreReponses + " est atteinte.";
                File.Delete(physicalPath);
                EventFinImport.Set();
                FinTraitement = true;
                return;
            }
        }
        MessageAnalyse += "Votes créés : " + nbVotes.ToString() + "<br/>";

        int nbScore = 0;

        foreach (DataTable dt in dataSet.Tables)
        {
            if (dt.TableName.Contains("Score"))
            {
                Score score  = Score.FillFromXML(dt.Rows[0]);
                int   status = Score.Create(score);
                if (status != 1)
                {
                    MessageAnalyse += "Erreur à la création du Score .<br/>";
                }
                else
                {
                    nbScore += 1;
                }
            }
        }
        MessageAnalyse += "Score créés : " + nbScore.ToString() + "<br/>";

        if (CheckBoxImportServeurSmtp.Checked)
        {
            foreach (DataTable dt in dataSet.Tables)
            {
                if (dt.TableName.Contains("SmtpServeur"))
                {
                    SmtpServer smtp = SmtpServer.FillFromXML(dt.Rows[0]);
                    smtp.UserGUID = MemberInfoData.MembreGUID;
                    int status = SmtpServer.Create(smtp);
                    if (status == 2)
                    {
                        MessageAnalyse += "Smtp : " + smtp.Email + " existe déjà.<br/>";
                        File.Delete(physicalPath);
                        EventFinImport.Set();
                        FinTraitement = true;
                        return;
                    }
                    else
                    {
                        MessageAnalyse += "Smtp crée correctement : " + smtp.Email + "<br/>";
                    }
                }
            }
        }

        DateTime dateFinAnalyse  = DateTime.Now;
        TimeSpan tempsTraitement = dateFinAnalyse - dateDebutAnalyse;

        MessageAnalyse += "- Taille du fichier : " + Tools.FileSizeFormat(DocumentNom.PostedFile.ContentLength, "N") + "<br/>";
        MessageAnalyse += "- Temps d'import : " + Tools.FormatTimeSpan(tempsTraitement) + "<br/>";

        File.Delete(physicalPath);
        EventFinImport.Set();
        FinTraitement = true;
    }
    protected void ButtonAjouterContacts_Click(object sender, EventArgs e)
    {
        ValidationMessage.Text     = "";
        ValidationMessage.CssClass = "LabelValidationMessageStyle";
        ValidationMessage.Visible  = true;

        if (TextBoxContactAjouter.Text.Trim() != "")
        {
            int countPersonne       = 0;
            int countEmailNonValide = 0;

            if (ValiderSeparateur(TextBoxContactAjouter.Text) == false)
            {
                ValidationMessage.Text     = "Erreur de séparateur : votre liste de contacts contient à la fois le séparateur \";\" et des retours chariots.";
                ValidationMessage.Text    += "<br/>Vous devez nettoyer votre liste.";
                ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
                return;
            }

            // Tester le format
            if (ContactValideFaconOutlook(TextBoxContactAjouter.Text))
            {
                string[] separateur = { ";" };
                string[] contacts   = TextBoxContactAjouter.Text.Split(separateur, StringSplitOptions.RemoveEmptyEntries);

                // Ici, on peut encore se faire avoir si la liste contient les deux formats
                string[] separateur2 = { "\r\n" };
                string[] contacts2   = TextBoxContactAjouter.Text.Split(separateur2, StringSplitOptions.RemoveEmptyEntries);
                if (contacts2.Length > contacts.Length)
                {
                    ValidationMessage.Text     = "Erreur de format : vous utilisez le format \"nom complet ([email protected])\" avec le séprateur retour chariot";
                    ValidationMessage.Text    += "<br/>Vous devez nettoyer votre liste.";
                    ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
                    return;
                }

                // Encore une verification, trop d'entree ici fait ramer le serveur d'une façon peu recommandable
                if (contacts.Length > int.Parse(Global.SettingsXml.LimitationImportsInterviewes))
                {
                    ValidationMessage.Text     = "Erreur : Taille maximum de la liste d'imports atteinte : " + Global.SettingsXml.LimitationImportsInterviewes;
                    ValidationMessage.Text    += "<br/>Vous devez réduire votre liste.";
                    ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
                    return;
                }

                //BRY00020100209
                if (SessionState.Limitations.LimitesInterviewesAtteinte(contacts.Length))
                {
                    Tools.PageValidation("La limite du nombre d'Interviewés : " + SessionState.Limitations.NombreInterviewes + " est atteinte.<br/>Contactez l'administrateur.");
                }

                // Trim()
                int i = 0;
                foreach (string s in contacts)
                {
                    contacts[i] = s.Trim();
                    i          += 1;
                }

                foreach (string contact in contacts)
                {
                    if (ContactValideFaconOutlook(contact))
                    {
                        string[] nomComplet = contact.Split('(');

                        int    idx1  = contact.IndexOf('(') + 1;
                        int    idx2  = contact.IndexOf(')');
                        string email = contact.Substring(idx1, idx2 - idx1);

                        if (Strings.IsValideEmail(email.Trim()))
                        {
                            Personne personne = new Personne();
                            personne.Nom         = nomComplet[0].Trim();
                            personne.EmailBureau = email.Trim();

                            personne.CodeAcces       = SessionState.Questionnaire.CodeAcces;
                            personne.QuestionnaireID = SessionState.Questionnaire.QuestionnaireID;
                            personne.PersonneGUID    = Guid.NewGuid();

                            string message = string.Empty;
                            int    status  = Personne.Create(personne, false, ref message);
                            if (status == 1)
                            {
                                countPersonne += 1;
                            }
                            else
                            {
                                ValidationMessage.Text    += message;
                                ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
                            }
                        }
                        else
                        {
                            ValidationMessage.Text += email.Trim() + " n'est pas un email valide<br/>";
                            countEmailNonValide    += 1;
                        }
                    }
                    else
                    {
                        ValidationMessage.Text += contact + " n'est pas un format valide<br/>";
                    }
                }
            }
            else if (ContactValideFaconListe(TextBoxContactAjouter.Text))
            {
                string contactAjouter = TextBoxContactAjouter.Text;
                string separateurDOS  = "\r\n";
                string separateurUnix = "\r";
                if (contactAjouter.Contains(separateurDOS) == false)
                {
                    if (contactAjouter.Contains(separateurUnix) == true)
                    {
                        ValidationMessage.Text += "Contacts au format Unix à importer<br/>";
                        contactAjouter          = Strings.UnixToDos(contactAjouter);
                    }
                }

                string[] separateur = { separateurDOS };
                string[] contacts   = TextBoxContactAjouter.Text.Split(separateur, System.StringSplitOptions.RemoveEmptyEntries);

                // Encore une verification, trop d'entree ici fait ramer le serveur d'une façon peu recommandable
                if (contacts.Length > int.Parse(Global.SettingsXml.LimitationImportsInterviewes))
                {
                    ValidationMessage.Text     = "Erreur : Taille maximum de la liste d'imports atteinte : " + Global.SettingsXml.LimitationImportsInterviewes;
                    ValidationMessage.Text    += "<br/>Vous devez réduire votre liste.";
                    ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
                    return;
                }

                //BRY00020100209
                if (SessionState.Limitations.LimitesInterviewesAtteinte(contacts.Length))
                {
                    Tools.PageValidation("La limite du nombre d'Interviewés : " + SessionState.Limitations.NombreInterviewes + " est atteinte.<br/>Contactez l'administrateur.");
                }

                // Trim()
                int i = 0;
                foreach (string s in contacts)
                {
                    contacts[i] = s.Trim();
                    i          += 1;
                }

                foreach (string contact in contacts)
                {
                    if (Strings.IsValideEmail(contact))
                    {
                        Personne personne = new Personne();
                        personne.Nom         = "";
                        personne.EmailBureau = contact;

                        personne.CodeAcces       = SessionState.Questionnaire.CodeAcces;
                        personne.QuestionnaireID = SessionState.Questionnaire.QuestionnaireID;
                        personne.PersonneGUID    = Guid.NewGuid();

                        string message = string.Empty;
                        int    status  = Personne.Create(personne, false, ref message);
                        if (status == 1)
                        {
                            countPersonne += 1;
                        }
                        else
                        {
                            ValidationMessage.Text    += message;
                            ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
                        }
                    }
                    else
                    {
                        ValidationMessage.Text += contact + " n'est pas un email valide<br/>";
                        countEmailNonValide    += 1;
                    }
                }
            }
            else if (TextBoxContactAjouter.Text.Length > 9 && TextBoxContactAjouter.Text.Substring(0, 9) == "Téléphone")
            {
                string contactAjouter = TextBoxContactAjouter.Text;
                string separateurDOS  = "\r\n";
                string separateurUnix = "\r";
                if (contactAjouter.Contains(separateurDOS) == false)
                {
                    if (contactAjouter.Contains(separateurUnix) == true)
                    {
                        ValidationMessage.Text += "Contacts au format Unix à importer<br/>";
                        contactAjouter          = Strings.UnixToDos(contactAjouter);
                    }
                }

                // Retirer la chaine "Téléphone"
                contactAjouter = contactAjouter.Substring(9 + separateurDOS.Length);

                string[] separateur = { separateurDOS };
                string[] contacts   = contactAjouter.Split(separateur, System.StringSplitOptions.RemoveEmptyEntries);

                // Encore une verification, trop d'entree ici fait ramer le serveur d'une façon peu recommandable
                if (contacts.Length > int.Parse(Global.SettingsXml.LimitationImportsInterviewes))
                {
                    ValidationMessage.Text     = "Erreur : Taille maximum de la liste d'imports atteinte : " + Global.SettingsXml.LimitationImportsInterviewes;
                    ValidationMessage.Text    += "<br/>Vous devez réduire votre liste.";
                    ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
                    return;
                }

                //BRY00020100209
                if (SessionState.Limitations.LimitesInterviewesAtteinte(contacts.Length))
                {
                    Tools.PageValidation("La limite du nombre d'Interviewés : " + SessionState.Limitations.NombreInterviewes + " est atteinte.<br/>Contactez l'administrateur.");
                }

                // Trim()
                int i = 0;
                foreach (string s in contacts)
                {
                    contacts[i] = s.Trim();
                    i          += 1;
                }

                foreach (string contact in contacts)
                {
                    if (Strings.IsValideTelephone(contact))
                    {
                        Personne personne = new Personne();
                        personne.Nom            = "";
                        personne.TelephonePerso = contact;

                        personne.CodeAcces       = SessionState.Questionnaire.CodeAcces;
                        personne.QuestionnaireID = SessionState.Questionnaire.QuestionnaireID;
                        personne.PersonneGUID    = Guid.NewGuid();

                        string message = string.Empty;
                        int    status  = Personne.Create(personne, false, ref message);
                        if (status == 1)
                        {
                            countPersonne += 1;
                        }
                        else
                        {
                            ValidationMessage.Text    += message;
                            ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
                        }
                    }
                    else
                    {
                        ValidationMessage.Text += contact + " n'est pas un numéro de téléphone valide<br/>";
                        countEmailNonValide    += 1;
                    }
                }
            }
            else if (TextBoxContactAjouter.Text.Length > 14 && TextBoxContactAjouter.Text.Substring(0, 14) == "Nom[Téléphone]")
            {
                string contactAjouter = TextBoxContactAjouter.Text;
                string separateurDOS  = "\r\n";
                string separateurUnix = "\r";
                if (contactAjouter.Contains(separateurDOS) == false)
                {
                    if (contactAjouter.Contains(separateurUnix) == true)
                    {
                        ValidationMessage.Text += "Contacts au format Unix à importer<br/>";
                        contactAjouter          = Strings.UnixToDos(contactAjouter);
                    }
                }

                // Retirer la chaine "Téléphone"
                contactAjouter = contactAjouter.Substring(14 + separateurDOS.Length);

                string[] separateur = { separateurDOS };
                string[] contacts   = contactAjouter.Split(separateur, StringSplitOptions.RemoveEmptyEntries);

                // Encore une verification, trop d'entree ici fait ramer le serveur d'une façon peu recommandable
                if (contacts.Length > int.Parse(Global.SettingsXml.LimitationImportsInterviewes))
                {
                    ValidationMessage.Text     = "Erreur : Taille maximum de la liste d'imports atteinte : " + Global.SettingsXml.LimitationImportsInterviewes;
                    ValidationMessage.Text    += "<br/>Vous devez réduire votre liste.";
                    ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
                    return;
                }

                //BRY00020100209
                if (SessionState.Limitations.LimitesInterviewesAtteinte(contacts.Length))
                {
                    Tools.PageValidation("La limite du nombre d'Interviewés : " + SessionState.Limitations.NombreInterviewes + " est atteinte.<br/>Contactez l'administrateur.");
                }

                // Trim()
                int i = 0;
                foreach (string s in contacts)
                {
                    contacts[i] = s.Trim();
                    i          += 1;
                }

                foreach (string contact in contacts)
                {
                    if (contact.Contains("[") == true && contact.Contains("]") == true)
                    {
                        string[] nomComplet = contact.Split('[');

                        int    idx1      = contact.IndexOf('[') + 1;
                        int    idx2      = contact.IndexOf(']');
                        string telephone = contact.Substring(idx1, idx2 - idx1);

                        if (Strings.IsValideTelephone(telephone.Trim()))
                        {
                            Personne personne = new Personne();
                            personne.Nom            = nomComplet[0].Trim();
                            personne.TelephonePerso = telephone.Trim();

                            personne.CodeAcces       = SessionState.Questionnaire.CodeAcces;
                            personne.QuestionnaireID = SessionState.Questionnaire.QuestionnaireID;
                            personne.PersonneGUID    = Guid.NewGuid();

                            string message = string.Empty;
                            int    status  = Personne.Create(personne, false, ref message);
                            if (status == 1)
                            {
                                countPersonne += 1;
                            }
                            else
                            {
                                ValidationMessage.Text    += message;
                                ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
                            }
                        }
                        else
                        {
                            ValidationMessage.Text += telephone.Trim() + " n'est pas un numéro de téléphone valide<br/>";
                            countEmailNonValide    += 1;
                        }
                    }
                    else
                    {
                        ValidationMessage.Text += contact + " n'est pas un format valide<br/>";
                    }
                }
            }
            else
            {
                ValidationMessage.Text     = "Ce n'est pas un format de contact valide";
                ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
            }

            ValidationMessage.Text += "<br/>Contacts importés avec succès : " + countPersonne.ToString();
            SessionState.Limitations.AjouterInterviewes(countPersonne);

            if (countEmailNonValide > 0)
            {
                ValidationMessage.Text += "<br/>Contacts non valides : " + countEmailNonValide.ToString();
            }
        }
        else
        {
            ValidationMessage.Text     = "La liste des contacts est vide";
            ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
        }

        SessionState.Personnes   = null; // BUG080909 forcer le recalcul de SessionState.Personnes.Count
        LabelNombreContacts.Text = SessionState.Personnes.Count.ToString();

        SqlDataSourcePersonne.SelectCommand = SelectCommand();
        GridViewContacts.DataBind();
    }
    protected void Page_Load(object sender, System.EventArgs e)
    {
        Trace.Warn("Page_Load:Begin");

        ValidationMessage.Text = "";
        LabelValidationMassageGridView.Text = "";

        // Choisir le premier Questionnaire a la place de l'utilisateur
        if (IsPostBack == false)
        {
            if (SessionState.Questionnaire == null && SessionState.Questionnaires.Count > 0)
            {
                SessionState.Questionnaire = SessionState.Questionnaires[0];
            }
        }

        if (IsPostBack == false)
        {
            CheckBoxListChoixParsing.Items.Add("CSV");
            CheckBoxListChoixParsing.Items.Add("Outlook");
        }

        if (IsPostBack == false)
        {
            /* Importer des contacts */
            if (Page.Request["cmd"] == "parse")
            {
                string erreurMessage       = "";
                int    countPersonne       = -1;
                int    countEmailNonValide = 0;
                if (ValiderContactsImportes == true)
                {
                    erreurMessage += "Vous devez d'abord valider les Contacts importés.";
                }
                else
                {
                    if (SessionState.Questionnaire == null)
                    {
                        erreurMessage += "Choisir un Questionnaire.";
                    }
                    else
                    {
                        string             filename  = Page.Request["file"].ToString();
                        bool               parseCSV  = CheckBoxListChoixParsing.TrueSelectedValue == "CSV" ? true : false;
                        PersonneCollection personnes = new PersonneCollection();
                        if (parseCSV == true)
                        {
                            erreurMessage = CarnetAdresse.ImportFile(filename, ref personnes);
                        }
                        else
                        {
                            erreurMessage = CarnetOutlook.ImportFile(filename, ref personnes);
                        }

                        // Traiter l'erreur d'importation
                        if (erreurMessage == "")
                        {
                            countPersonne = 0; // L'import s'est bien passe
                        }
                        else
                        {
                            ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
                        }

                        // BRY00020100209
                        if (SessionState.Limitations.LimitesInterviewesAtteinte(personnes.Count))
                        {
                            Tools.PageValidation("La limite du nombre d'Interviewés : " + SessionState.Limitations.NombreInterviewes + " est atteinte.<br/>Contactez l'administrateur.");
                        }

                        foreach (Personne p in personnes)
                        {
                            // Corriger les petites merdouilles d'Outlook (pour outlook c'est adr1 adr2 adr3 ...
                            // et oui la rubrique "Classer sous" peut contenir une ',' qui met a mal l'algo !
                            if ((p.EmailBureau == "" || !p.EmailBureau.Contains("@")) && p.EmailPerso != "")
                            {
                                p.EmailBureau = p.EmailPerso;
                            }
                            p.EmailBureau     = p.EmailBureau.Trim();
                            p.TelephonePerso  = p.TelephonePerso.Trim();
                            p.TelephoneBureau = p.TelephoneBureau.Trim();
                            if (p.TelephonePerso == string.Empty && p.TelephoneBureau != string.Empty)
                            {
                                p.TelephonePerso = p.TelephoneBureau;
                            }
                            p.CodeAcces       = SessionState.Questionnaire.CodeAcces;
                            p.QuestionnaireID = SessionState.Questionnaire.QuestionnaireID;
                            p.PersonneGUID    = Guid.NewGuid();

                            int status = Personne.Create(p, false, ref erreurMessage);
                            if (status == 1)
                            {
                                countPersonne += 1;
                            }
                            else
                            {
                                countEmailNonValide += 1;
                            }
                        }

                        // A la fin de la sequence d'importation l'url contient les chaines cmd et file
                        // je ne trouve que ce moyen pour obliger l'url a se cleaner sinon
                        // on recommence le parsing indefiniment
                        ValiderContactsImportes = true;
                    }
                }
                PanelValiderContactImport.Visible = ValiderContactsImportes;

                // Interpreter le message d'erreur,
                // s'il n'est pas vide il contient les contacts que l'on n'a pas pu importer
                if (erreurMessage != "")
                {
                    ValidationMessage.Visible = true;
                    ValidationMessage.Text    = erreurMessage;
                }
                else
                {
                    ValidationMessage.Visible = true;
                }

                if (countPersonne != -1)
                {
                    ValidationMessage.Text += "<br/>Contacts importés avec succès : " + countPersonne.ToString();
                    // Si, malgres tout on a reussi a importer des contacts on l'ecrit en bleu
                    ValidationMessage.CssClass = "LabelValidationMessageStyle";
                    SessionState.Limitations.AjouterInterviewes(countPersonne);
                }

                if (countEmailNonValide > 0)
                {
                    ValidationMessage.Text += "<br/>Contacts non valides : " + countEmailNonValide.ToString();
                }
            }/* Importer des contacts */

            if (SessionState.Questionnaire == null)
            {
                LabelCodeAccess.Text    = "Invalide";
                LabelQuestionnaire.Text = "";
                // Pas de Questionnaire, pas de bouton nouveau contact
                RolloverLinkEdit.Visible = false;
            }
            else
            {
                LabelCodeAccess.Text    = SessionState.Questionnaire.CodeAcces.ToString();
                LabelQuestionnaire.Text = SessionState.Questionnaire.Description;
                BloquerQuestionnaire(SessionState.Questionnaire.Bloque);
            }

            /* L'alphabet */
            DropDownListLettre.Items.Add("---");
            string   _alpha = "A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z";
            string[] alpha  = _alpha.Split(',');
            foreach (string s in alpha)
            {
                DropDownListLettre.Items.Add(s);
            }

            GridViewContacts.PageSize           = SessionState.ContactsParPage;
            GridViewContacts.PageIndex          = CurrentPageIndex;
            TextBoxContactsParPage.Text         = SessionState.ContactsParPage.ToString();
            SqlDataSourcePersonne.SelectCommand = SelectCommand();
            GridViewContacts.DataBind();

            SessionState.Personnes = null; // BUG080909 forcer le recalcul de SessionState.Personnes.Count
        }
        // BUG1107090001
        LabelNombreContacts.Text = SessionState.Personnes == null ? "0" : SessionState.Personnes.Count.ToString();

        Trace.Warn("Page_Load:End");
    }
Esempio n. 4
0
    protected void ButtonSave_Click(object sender, EventArgs e)
    {
        ValidationMessage.Text     = "";
        ValidationMessage.CssClass = "LabelValidationMessageStyle";

        // BUG0809090002
        //if ( TextBoxNom.Text.Trim().Length == 0 )
        //{
        //    ValidationMessage.Text += "Entrer un Nom<br/>";
        //    ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
        //}
        // Le prenom n'est pas obligatoire, peut etre vide
        //if ( TextBoxPrenom.Text.Trim().Length == 0 )
        //{
        //    ValidationMessage.Text += "Entrer un Prénom<br/>";
        //    ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
        //}
        if (Global.SettingsXml.EnregistrerContactAvecSociete && TextBoxSociete.Text.Trim().Length == 0)
        {
            ValidationMessage.Text    += "Entrer une Société<br/>";
            ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
        }
        // AME16062010
        TextBoxEmail.Text     = TextBoxEmail.Text.Trim();
        TextBoxTelephone.Text = TextBoxTelephone.Text.Trim();
        if (TextBoxEmail.Text.Length == 0 && TextBoxTelephone.Text.Length == 0)
        {
            ValidationMessage.Text    += "Entrer un E-mail ou un Numéro de Téléphone<br/>";
            ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
        }
        else
        {
            if (TextBoxTelephone.Text.Length != 0)
            {
                if (Strings.IsValideTelephone(TextBoxTelephone.Text) == false)
                {
                    ValidationMessage.Text    += "Ce numéro de téléphone n'est pas valide<br/>";
                    ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
                }
            }
            if (TextBoxEmail.Text.Length != 0)
            {
                if (Strings.IsValideEmail(TextBoxEmail.Text) == false)
                {
                    ValidationMessage.Text    += "Ce n'est pas un email valide<br/>";
                    ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
                }
            }
        }
        // AME26062010
        //if ( TextBoxCodeAcces.Text.Trim().Length == 0 )
        //{
        //    ValidationMessage.Text += "Entrer un Code d'accès<br/>";
        //    ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
        //}

        if (ValidationMessage.Text != "")
        {
            ValidationMessage.Visible = true;
            return;
        }

        // C'est une mise a jour
        if (PersonneID != 0)
        {
            Personne personne = Personne.Get(PersonneID);
            personne.EmailEnvois    = 0;
            personne.Civilite       = TextBoxCivilite.Text;
            personne.Prenom         = TextBoxPrenom.Text;
            personne.Nom            = TextBoxNom.Text;
            personne.Societe        = TextBoxSociete.Text;
            personne.EmailBureau    = TextBoxEmail.Text;
            personne.TelephonePerso = TextBoxTelephone.Text;
            string message = string.Empty;
            int    retCode = Personne.Update(personne, ref message);
            ValidationMessage.Text += message;
            if (retCode != 0)
            {
                ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
            }
        }
        else // C'est une creation
        {
            //BRY00020100209
            if (SessionState.Limitations.LimitesInterviewesAtteinte(1))
            {
                Tools.PageValidation("La limite du nombre d'Interviewés : " + SessionState.Limitations.NombreInterviewes + " est atteinte.<br/>Contactez l'administrateur.");
            }

            Personne personne = new Personne();
            personne.Civilite        = TextBoxCivilite.Text;
            personne.Nom             = TextBoxNom.Text;
            personne.Prenom          = TextBoxPrenom.Text;
            personne.Societe         = TextBoxSociete.Text;
            personne.EmailBureau     = TextBoxEmail.Text;
            personne.TelephonePerso  = TextBoxTelephone.Text;
            personne.CodeAcces       = SessionState.Questionnaire.CodeAcces;
            personne.QuestionnaireID = SessionState.Questionnaire.QuestionnaireID;
            personne.PersonneGUID    = Guid.NewGuid();

            string message = string.Empty;
            int    retCode = Personne.Create(personne, true, ref message);
            if (retCode == 1)
            {
                ValidationMessage.Text += message;
                SessionState.Limitations.AjouterInterviewes(1);
            }
            else
            {
                ValidationMessage.Text    += message;
                ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
            }
        }

        ValidationMessage.Visible = true;
    }
    protected void ButtonRepondre_Click(object sender, EventArgs e)
    {
        // Est-ce un Robo ?
        if (IsCaptchaValid == false || Page.IsValid == false)
        {
            Response.Redirect(Tools.PageErreurPath + "IP:" + Request.UserHostAddress.ToString() + "<br/>Coming from:" + Request.UrlReferrer.ToString() + "<br/>Is Robot");
        }

        Questionnaire questionnaire = Questionnaire.GetQuestionnaire(QuestionnaireID);

        // Anonyme et Anonyma on enregistre un anonyme
        if (questionnaire.Anonyme && questionnaire.Anonymat)
        {
            PersonneCollection personnes = PersonneCollection.GetQuestionnaire(questionnaire.QuestionnaireID);

            Personne anonyme = new Personne();
            // PREMIERE IDEE MAUVAISE anonyme.ID_Personne = 0; // distinguer un utilisateur anonymat complet d'un contact enregistre
            anonyme.PersonneGUID    = Guid.NewGuid();
            anonyme.QuestionnaireID = questionnaire.QuestionnaireID;
            // BUG20112009
            //anonyme.Nom = "Anonyme" + ( personnes.Count + 1 ).ToString();
            //anonyme.EmailBureau = "Anonyme" + ( personnes.Count + 1 ).ToString();
            //anonyme.Prenom = "Anonyme" + ( personnes.Count + 1 ).ToString();
            anonyme.Nom         = "";
            anonyme.EmailBureau = anonyme.PersonneGUID.ToString() + "@a.fr"; //BUG23072010
            anonyme.Prenom      = "";
            anonyme.CodeAcces   = questionnaire.CodeAcces;
            anonyme.EmailEnvois = 0;

            // Trouver si l'utilisateur de ce questionnaire est limite
            Limitation limitation = new Limitation(questionnaire.MembreGUID);
            if (limitation.LimitesInterviewes)
            {
                Response.Redirect(Tools.PageErreurPath + "Désolé, la limite du nombre d'Interviewés pour ce questionnaire est atteinte.", true);
            }

            // Enregistrement de l'interviewe avec anonymat complet
            string message = string.Empty;
            int    retCode = Personne.Create(anonyme, true, ref message);
            if (retCode == 1)
            {
                SessionState.Personne = anonyme;
            }
            else if (retCode == 2)
            {
                ValidationMessage.Text    += message;
                ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
            }
        }

        if (SessionState.Personne == null)
        {
            ValidationMessage.Text    += "Vous n'êtes pas enregistrez";
            ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
            ValidationMessage.Visible  = true;
        }
        else
        {
            // Regarder si il y a au moins une Question pour ce Questionnaire
            SessionState.Questions = PollQuestionCollection.GetByQuestionnaire(SessionState.Personne.QuestionnaireID);
            if (SessionState.Questions.Count > 0)
            {
                Response.Redirect("~/Poll/Questionnaire.aspx?QuestionnaireID=" + SessionState.Personne.QuestionnaireID.ToString(), true);
            }
            else
            {
                Response.Redirect(Tools.PageErreurPath + "Désolé mais il n'y a pas de Questions pour ce Questionnaire.");
            }
        }
    }
    protected void ButtonEnregistrer_Click(object sender, EventArgs e)
    {
        // Est-ce un Robo ?
        if (IsCaptchaValid == false || Page.IsValid == false)
        {
            Response.Redirect(Tools.PageErreurPath + "IP:" + Request.UserHostAddress.ToString() + "<br/>Coming from:" + Request.UrlReferrer.ToString() + "<br/>Is Robot");
        }

        ValidationMessage.Text     = "";
        ValidationMessage.CssClass = "LabelValidationMessageStyle";

        // Validation du Formulaire suivant son mode
        bool nomPrenomSociete =
            ModeFormulaire == Mode.Complet ||
            ModeFormulaire == Mode.CompletEmail ||
            ModeFormulaire == Mode.CompletTelephone;

        if (nomPrenomSociete)
        {
            if (TextBoxNom.Text.Trim().Length == 0)
            {
                ValidationMessage.Text    += "Entrer un Nom<br/>";
                ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
            }
            if (TextBoxPrenom.Text.Trim().Length == 0)
            {
                ValidationMessage.Text    += "Entrer un Prénom<br/>";
                ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
            }
            if (Global.SettingsXml.EnregistrerContactAvecSociete && TextBoxSociete.Text.Trim().Length == 0)
            {
                ValidationMessage.Text    += "Entrer une Société<br/>";
                ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
            }
        }

        if ((nomPrenomSociete || ModeFormulaire == Mode.Email) &&
            (ModeFormulaire == Mode.Telephone) == false &&
            (ModeFormulaire == Mode.CompletTelephone) == false)
        {
            if (TextBoxEmail.Text.Trim().Length == 0)
            {
                ValidationMessage.Text    += "Entrer un E-mail<br/>";
                ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
            }
            else
            {
                if (Strings.IsValideEmail(TextBoxEmail.Text) == false)
                {
                    ValidationMessage.Text    += "Ce n'est pas un email valide<br/>";
                    ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
                }
            }
        }

        if ((nomPrenomSociete || ModeFormulaire == Mode.Telephone) &&
            (ModeFormulaire == Mode.Email) == false &&
            (ModeFormulaire == Mode.CompletEmail) == false)
        {
            if (TextBoxTelephone.Text.Trim().Length == 0)
            {
                ValidationMessage.Text    += "Entrer un Numéro de téléphone<br/>";
                ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
            }
            else
            {
                if (Strings.IsValideTelephone(TextBoxTelephone.Text) == false)
                {
                    ValidationMessage.Text    += "Ce numéro de téléphone n'est pas valide<br/>";
                    ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
                }
            }
        }

        if (ValidationMessage.Text != "")
        {
            ValidationMessage.Visible = true;
            return;
        }

        Questionnaire questionnaire = Questionnaire.GetQuestionnaire(QuestionnaireID);

        Personne personne = new Personne();

        personne.Civilite        = TextBoxCivilite.Text;
        personne.Nom             = TextBoxNom.Text;
        personne.Prenom          = TextBoxPrenom.Text;
        personne.Societe         = TextBoxSociete.Text;
        personne.EmailBureau     = TextBoxEmail.Text;
        personne.TelephonePerso  = TextBoxTelephone.Text;
        personne.CodeAcces       = questionnaire.CodeAcces;
        personne.EmailEnvois     = 0;
        personne.QuestionnaireID = questionnaire.QuestionnaireID;
        personne.PersonneGUID    = Guid.NewGuid();

        // Trouver si l'utilisateur de ce questionnaire est limite
        Limitation limitation = new Limitation(questionnaire.MembreGUID);

        if (limitation.LimitesInterviewes)
        {
            Response.Redirect(Tools.PageErreurPath + "Désolé, la limite du nombre d'Interviewés pour ce questionnaire est atteinte.", true);
        }

        string message = string.Empty;
        int    retCode = Personne.Create(personne, true, ref message);

        if (retCode == 1)
        {
            ValidationMessage.Text   += "Vous êtes enregistré pour répondre au Questionnaire : " + questionnaire.Description + "<br/>";
            SessionState.Personne     = personne;
            ButtonRepondre.Visible    = true;
            ButtonEnregistrer.Visible = false;

            TextBoxCivilite.Enabled  = false;
            TextBoxNom.Enabled       = false;
            TextBoxPrenom.Enabled    = false;
            TextBoxSociete.Enabled   = false;
            TextBoxEmail.Enabled     = false;
            TextBoxTelephone.Enabled = false;
        }
        else if (retCode == 2)
        {
            ValidationMessage.Text     = message;
            ValidationMessage.CssClass = "LabelValidationMessageErrorStyle";
        }

        ValidationMessage.Visible = true;
    }
Esempio n. 7
0
        // Transforme la table en string
        public static string ImportFile(string fileName, ref PersonneCollection personnes)
        {
            string       erreurMessage = "";
            FileStream   fs            = new FileStream(fileName, FileMode.Open, FileAccess.Read);
            StreamReader sr            = new StreamReader(fs, Encoding.UTF7);
            string       s             = sr.ReadToEnd();

            fs.Close();
            sr.Close();

            string[] separateurLigne = { "\"Non spécifié\"\r\n", "\"Utilisateur 4\"\r\n" }; // Une hyptohese risquee
            string[] lignes          = s.Split(separateurLigne, StringSplitOptions.RemoveEmptyEntries);
            if (lignes.Length <= 1)
            {
                erreurMessage = "Ce fichier n'est pas au format du carnet outlook.<br>";
                return(erreurMessage);
            }

            string entete = lignes[0];

            char[]   separteurValeur = { ',', '\"' };
            string[] entetes         = entete.Split(separteurValeur, StringSplitOptions.RemoveEmptyEntries);
            if (entetes.Length <= 1)
            {
                erreurMessage = "Ce fichier n'est pas au format du carnet outlook.<br>";
                return(erreurMessage);
            }

            // La deuxieme colonne Nom pose un probleme c'est le nom complet
            // mais on en veut pas d'ou ce caviardage par une colonne qui n'existe pas
            // entetes[ 3 ] = "aaaaaaaaa"; Non faut pas ya pas de non complet dans outlook de merde et si !! putain de bordel quelle merde enfin microsoft est donne son plein potentiel !!
            // outlook de merde on trouve 2 colonnes Titre une pour civlite ou autre pour ...
            // donc ici on ruse a mort

            ColonneCollection cc = new ColonneCollection(HeaderColumns);
            ColonneCollection colonnesExistantes = new ColonneCollection();

            if (entetes[0] == "Titre")
            {
                cc[0].Existe = true;
                cc[0].Indice = 0;
                colonnesExistantes.Add(cc[0]);
                cc.RemoveAt(0);
            }

            foreach (Colonne c in cc)
            {
                for (int i = 1; i < entetes.Length; i++)
                {
                    if (c.Nom.CompareTo(entetes[i]) == 0)
                    {
                        // La colonne existe dans le fichier
                        c.Existe = true;
                        c.Indice = i;
                        colonnesExistantes.Add(c);
                    }
                }
            }

            if (colonnesExistantes.Count <= 0)
            {
                erreurMessage = "Format de fichier non valide.<br>";
                return(erreurMessage);
            }

            //BRY00020100209
            if (SessionState.Limitations.LimitesInterviewesAtteinte(lignes.Length))
            {
                Tools.PageValidation("La limite du nombre d'Interviewés : " + SessionState.Limitations.NombreInterviewes + " est atteinte.<br/>Contactez l'administrateur.");
            }

            // Le split marche dans l'entete car on RemoveEmptyEntries
            // ici on ne peut pas le faire pour garder le bon indice de la place de la valeur
            // et donc on recommence ...
            string[] separateurVal = { "\",\"" };
            for (int i = 1; i < lignes.Length; i++)
            {
                string[] valeurs = lignes[i].Split(',');
                for (int v = 0; v < valeurs.Length; v++)
                {
                    valeurs[v] = SupprimeCaractereDeMerde(valeurs[v]);
                }

                Personne p = new Personne();
                foreach (Colonne c in colonnesExistantes)
                {
                    if (c.Existe)
                    {
                        if (c.Nom == HeaderColumns[0])
                        {
                            p.Civilite = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[1])
                        {
                            p.Nom = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[2])
                        {
                            p.Prenom = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[3])
                        {
                            p.Societe = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[4])
                        {
                            p.Fonction = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[5])
                        {
                            p.EmailPerso = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[6])
                        {
                            p.EmailBureau = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[7])
                        {
                            p.Adresse = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[8])
                        {
                            p.Ville = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[9])
                        {
                            p.CodePostal = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[10])
                        {
                            p.TelephonePerso = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[11])
                        {
                            p.TelephoneBureau = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[12])
                        {
                            p.TelephoneMobile = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[13])
                        {
                            p.Fax = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[14])
                        {
                            p.LienHTML = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[15])
                        {
                            p.Memo = valeurs[c.Indice];
                        }
                    }
                }

                if (personnes == null)
                {
                    int ret = Personne.Create(p, true, ref erreurMessage);
                }
                else
                {
                    personnes.Add(p);
                }
            }

            return(erreurMessage);
        }
Esempio n. 8
0
        /// <summary>
        /// Lecture du fichier au format CVS creation d'une personne
        /// </summary>
        /// <param name="fileName">le fichier</param>
        /// <param name="personnes">collection de personnes si null on cree dans la database</param>
        /// <returns></returns>
        public static string ImportFile(string fileName, ref PersonneCollection personnes)
        {
            string       erreurMessage = "";
            FileStream   fs            = new FileStream(fileName, FileMode.Open, FileAccess.Read);
            StreamReader sr            = new StreamReader(fs, Encoding.UTF7);
            string       s             = sr.ReadToEnd();

            fs.Close();
            sr.Close();

            string separateurDOS  = "\r\n";
            string separateurUnix = "\r";

            if (s.Contains(separateurDOS) == false)
            {
                if (s.Contains(separateurUnix) == false)
                {
                    erreurMessage = "Ce fichier n'est ni au format Unix ni au format DOS.<br>";
                    return(erreurMessage);
                }
                erreurMessage += "Conversion du fichier Unix vers DOS.<br>";
                s              = Strings.UnixToDos(s);
            }

            string[] separateur = { "\r\n" };
            string[] lignes     = s.Split(separateur, System.StringSplitOptions.None);
            string   entete     = lignes[0];

            string[] entetes = entete.Split(';');

            if (entetes.Length <= 2)
            {
                erreurMessage = "Ce fichier n'est pas au format du carnet d'adresses.<br>";
                return(erreurMessage);
            }

            // La deuxieme colonne Nom pose un probleme c'est le nom complet
            // mais on n'en veut pas d'ou ce caviardage par une colonne qui n'existe pas
            // sauf si le fichier vient d'excel dans ce cas on ne ve pas faire chier l'utilisateur !
            //if ( entetes.Length > 3 ) entetes[ 3 ] = "aaaaaaaaa"; RAS LE BOL JE SAIS PLUS

            ColonneCollection cc = new ColonneCollection(HeaderColumns);
            ColonneCollection colonnesExistantes = new ColonneCollection();

            // Enregistrer les colonnes qui existent
            for (int i = 0; i < entetes.Length; i++)
            {
                foreach (Colonne c in cc)
                {
                    if (c.Nom.CompareTo(entetes[i]) == 0)
                    {
                        // La colonne existe dans le fichier
                        c.Existe = true;
                        c.Indice = i;
                        colonnesExistantes.Add(c);
                    }
                }
            }

            if (colonnesExistantes.Count <= 0)
            {
                erreurMessage = "Format de fichier non valide.<br>";
                return(erreurMessage);
            }

            //BRY00020100209
            if (SessionState.Limitations.LimitesInterviewesAtteinte(lignes.Length))
            {
                Tools.PageValidation("La limite du nombre d'Interviewés : " + SessionState.Limitations.NombreInterviewes + " est atteinte.<br/>Contactez l'administrateur.");
            }

            // La derniere ligne peut etre vide
            for (int i = 1; i < lignes.Length && lignes[i] != ""; i++)
            {
                // Incroyable on voit Excel de daube qui met des ';' a lin de la ligne
                // mais il s'arrete au bout de 15 lignes et il en met plus !!!
                string[] essai = lignes[i].Split(';');
                if (essai.Length < colonnesExistantes.Count)
                {
                    // Il manque une colonne !
                    // Donc on ajoute une colonne vide !
                    lignes[i] = lignes[i] + ";";
                }

                string[] valeurs = lignes[i].Split(';');

                Personne p = new Personne();

                foreach (Colonne c in colonnesExistantes)
                {
                    if (c.Existe)
                    {
                        if (c.Nom == HeaderColumns[0])
                        {
                            p.Civilite = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[1])
                        {
                            p.Nom = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[2])
                        {
                            p.Prenom = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[3])
                        {
                            p.EmailBureau = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[4])
                        {
                            p.Adresse = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[5])
                        {
                            p.Ville = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[6])
                        {
                            p.CodePostal = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[7])
                        {
                            p.TelephonePerso = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[8])
                        {
                            p.TelephoneBureau = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[9])
                        {
                            p.TelephoneMobile = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[10])
                        {
                            p.Fax = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[11])
                        {
                            p.Societe = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[12])
                        {
                            p.Fonction = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[13])
                        {
                            p.LienHTML = valeurs[c.Indice];
                        }
                        if (c.Nom == HeaderColumns[14])
                        {
                            p.Memo = valeurs[c.Indice];
                        }
                    }
                }

                if (personnes == null)
                {
                    int ret = Personne.Create(p, true, ref erreurMessage);
                }
                else
                {
                    personnes.Add(p);
                }
            }

            return(erreurMessage);
        }