public void CreateUploadMessages(BO.ORCID.Person person, string loggedInInternalUsername)
        {
            // Before opening the transaction get the 'read limited' token if it exists.
            // if it does not exist or is expired we will create a message to update it.
            BO.ORCID.PersonToken personToken = new BLL.ORCID.PersonToken().GetByPersonIDAndPermissionID(person.PersonID, (int)BO.ORCID.REFPermission.REFPermissions.orcid_profile_read_limited);

            using (System.Data.Common.DbTransaction trans = base.GetEditTransaction())
            {
                try
                {
                    new ProfilesRNSDLL.BLL.ORCID.Person().Edit(person, trans);
                    if (!personToken.Exists || personToken.IsExpired)
                    {
                        CreateMessageToReadLimited(person, trans);
                    }
                    if (person.PushBiographyToORCID || (person.HasURLsToPush))
                    {
                        CreateBioUpdateMessage(person, trans, loggedInInternalUsername);
                    }
                    WorksUpdate(person, trans);
                    AffiliationsUpdate(person, trans);
                    trans.Commit();
                }
                catch (Exception ex)
                {
                    trans.Rollback();
                    throw ErrorLog.LogError(ex, loggedInInternalUsername, "An error occurred while generating the messages to send to ORCID.");
                }
            }
        }

 public void UpdateUserToken(Dictionary<string, object> items, BO.ORCID.Person person, string loggedInInternalUsername)
 {
     try
     {
         BO.ORCID.PersonToken accessToken = PersonToken.GetAPIUserAccessToken(items, person);
         if (!Save(accessToken))
         {
             throw new Exception("An unexpected error occurred while saving the token");
         }
         if (accessToken.PermissionID == (int)BO.ORCID.REFPermission.REFPermissions.orcid_profile_read_limited)
         {
             BLL.ORCID.PersonMessage personMessageBLL = new PersonMessage();
             List<BO.ORCID.PersonMessage> personMessages = personMessageBLL.GetByPersonIDAndRecordStatusIDAndPermissionID(person.PersonID,
                 (int)BO.ORCID.REFRecordStatus.REFRecordStatuss.Waiting_for_ORCID_User_for_approval,
                 (int)accessToken.PermissionID, false);
             foreach (BO.ORCID.PersonMessage personMessage in personMessages)
             {
                 personMessage.RecordStatusID = (int)BO.ORCID.REFRecordStatus.REFRecordStatuss.Success;
                 if (!personMessageBLL.Save(personMessage))
                 {
                     throw new Exception("Token was saved but an unexpected error occurred while updating the related messages.");
                 }
             }
         }
     }
     catch (Exception ex)
     {
         throw BLL.ORCID.ErrorLog.LogError(ex, loggedInInternalUsername, "Error saving token information to table: ProfileToken in databae: BUMC_ORCID.");
     }
 }

        /// <summary>
        /// Enregistre la participation d'un élève d'ybe section à une UF.
        /// </summary>
        /// <param name="section">Section de l'élève</param>
        /// <param name="eleve">Elève dont on enregistre la participation à une UF</param>
        /// <param name="uf">UF à laquelle l'élève participe</param>
        /// <param name="cote">Cote de l'élève</param>
        /// <param name="date">Date de l'examen</param>
        public static void Participer(BO.Section section, BO.Eleve eleve, BO.UF uf, int cote, DateTime date)
        {
            List<BO.UF> participations = DAL.AccesUF.ChargerParticipations(eleve, section);
            // soit l'uf a déjà été tentée, dans ce cas on update la participation
            // soit l'uf n'a jamais été tentée, dans ce cas on insère une nouvelle participation
            bool existe = false;
            foreach (BO.UF participation in participations)
            {
                if (participation.Id == uf.Id)
                {
                    existe = true;
                    break;
                }
            }

            if (existe)
            {
                // update
                DAL.AccesUF.MajParticipation(section, eleve, uf, cote, date);
            }
            else
            {
                // insert
                DAL.AccesUF.InsererParticipation(section, eleve, uf, cote, date);
            }
        }

 /// <summary>
 /// Charge la liste des UF possibles d'un élève d'une section.
 /// </summary>
 /// <param name="section">Section à laquelle l'élève appartient</param>
 /// <param name="eleve">Elève dont on veut récupérer la liste des UF possibles</param>
 /// <returns>Liste des UF possibles</returns>
 public static List<BO.UF> ChargerUFPossibles(BO.Section section, BO.Eleve eleve)
 {
     List<BO.UF> retVal = new List<BO.UF>();
     List<BO.UF> ufRéussies = DAL.AccesUF.ChargerUFRéussies(eleve, section);
     List<BO.UF> ufCandidates = chargerUFNonRéussies(section, eleve, ufRéussies);
     List<BO.Groupe> groupes = DAL.AccesGroupe.ChargerGroupes();
     List<BO.Prérequis> prérequis = DAL.AccesRequerir.ChargerPrérequis();
     // On filtre les UF selon leur prérequis
     foreach (BO.UF uf in ufCandidates)
     {
         int cptGroupes = 0;
         int cptGroupesOK = 0;
         foreach (BO.Groupe groupe in groupes)
         {
             if (groupe.IdUF == uf.Id)
             {
                 cptGroupes += 1;
                 if (vérifierGroupe(groupe, prérequis, ufRéussies))
                     cptGroupesOK += 1;
             }
         }
         // Il faut au moin avoir réussis un groupe de prérequis (s'il y en a)
         if(cptGroupes == 0 || cptGroupesOK >= 1)
             retVal.Add(uf);
     }
     return retVal;
 }

 private void GetPersonAffiliationID(BO.ORCID.PersonAffiliation personAffiliation)
 {
     BO.ORCID.PersonAffiliation personAffiliationExisting = base.GetByProfilesIDAndAffiliationTypeID(personAffiliation.ProfilesID, personAffiliation.AffiliationTypeID);
     if (personAffiliationExisting.Exists)
     {
         personAffiliation.PersonAffiliationID = personAffiliationExisting.PersonAffiliationID;
     }
 }

 /// <summary>
 /// Ctor
 /// </summary>
 /// <param name="uf">UF concernée</param>
 public DlgParticiper(BO.UF uf)
 {
     InitializeComponent();
     this.Text = uf.Libellé;
     this.coteMax = uf.NbHeures * 10;
     this.lblRésultats.Text = "Résultats ( /" + this.coteMax.ToString() + ")";
     this.btOk.Enabled = false;
 }

 public override void Update(BO.BOBase us)
 {
     BO.User u = us as BO.User;
     int error = 0;
     List<SqlParameter> userparam = fillParams(u);
     userparam.Add(DAL.CommonMethods.parameter("w_UserID", u.ID));
     DAL.CommonMethods.UpdateDataTable("usp_update_AggregateUser", out error, userparam.ToArray());
 }

 public override void Create(BO.BOBase us)
 {
     BO.User u = us as BO.User;
     int error = 0;
     int identity = 0;
     DAL.CommonMethods.UpdateDataTable("usp_insert_AggregateUser",out error, out identity, fillParams(u).ToArray());
     u.ID = identity;
 }

        public void SendORCIDXMLMessage(BO.ORCID.Person person, string accessToken, BO.ORCID.PersonMessage personMessage, BO.ORCID.REFPermission refPermission)
        {
            List<string> responseMessage = new List<string>();
            BLL.ORCID.PersonMessage personMessageBLL = new PersonMessage();
            personMessage.RequestURL = ProfilesRNSDLL.BO.ORCID.Config.ORCID_API_URL_WITH_VERSION + "/" + person.ORCID + "/" + refPermission.MethodAndRequest;
            InitializePersonMessageRequestInfo(personMessage, personMessageBLL);

            string method = System.Net.WebRequestMethods.Http.Post.ToString();
            if (personMessage.PermissionID == (int)BO.ORCID.REFPermission.REFPermissions.orcid_bio_update)
            {
                method = System.Net.WebRequestMethods.Http.Put.ToString();
            }

            string msg = string.Empty;

            WebRequest httpWebRequest = WebRequest.Create(personMessage.RequestURL);
            httpWebRequest.ContentType = "application/orcid+xml";
            httpWebRequest.Method = method;

            NameValueCollection param2 = new NameValueCollection();
            string AuthBearer = "Authorization: Bearer " + accessToken;
            responseMessage.Add(AuthBearer);

            param2.Add("Authorization", " Bearer " + accessToken);

            foreach (var key in param2.AllKeys)
            {
                httpWebRequest.Headers.Add(key, param2[key]);
            }

            string profile = personMessage.XML_Sent;

            byte[] xmlBytes = Encoding.UTF8.GetBytes(profile);
            using (var requestStream = httpWebRequest.GetRequestStream())
            {
                requestStream.Write(xmlBytes, 0, xmlBytes.Length);
                requestStream.Close();
            }
            try
            {
                using (WebResponse response = httpWebRequest.GetResponse())
                {
                    HttpWebResponse httpResponse = (HttpWebResponse)response;
                    using (Stream data = response.GetResponseStream())
                    {
                        string text = new StreamReader(data).ReadToEnd();
                        personMessage.HttpResponseCode = httpResponse.StatusCode.ToString();
                        responseMessage.Add(text);
                        personMessage.MessagePostSuccess = true;
                    }
                }
            }
            catch (WebException en)
            {
                ProcessWebException(personMessage, en, httpWebRequest);
            }
            SavePersonMessage(personMessage, refPermission, personMessageBLL);
        }

 public void ReadORCIDProfile(BO.ORCID.Person person, BO.ORCID.PersonMessage personMessage, BO.ORCID.REFPermission refPermission, string loggedInInternalUsername)
 {
     personMessage.RequestURL = ProfilesRNSDLL.BO.ORCID.Config.ORCID_API_URL_WITH_VERSION + "/" + person.ORCID + "/" + refPermission.MethodAndRequest;
     NameValueCollection param2 = new NameValueCollection();
     string token = BLL.ORCID.OAuth.GetClientToken(refPermission.PermissionScope, loggedInInternalUsername);
     param2.Add("Authorization", " Bearer " + token);
     param2.Add("Scope", refPermission.PermissionScope);
     GetWebResponseMethodGet(personMessage, refPermission, param2);
 }

 internal static void SetPersonMessageID(BO.ORCID.Person person)
 {
     if (person.URLs != null && person.URLs.Count > 0)
     {
         foreach (BO.ORCID.PersonURL personURL in person.URLs)
         {
             personURL.PersonMessageID = person.PersonMessage.PersonMessageID;
         }
     }
 }

 public BO.ORCID.PersonMessage Create(BO.ORCID.Person person, BO.ORCID.REFPermission refPermission)
 {
     ProfilesRNSDLL.BO.ORCID.PersonMessage personMessage = new ProfilesRNSDLL.BO.ORCID.PersonMessage();
     personMessage.PermissionID = refPermission.PermissionID;
     personMessage.RecordStatusID = (int)ProfilesRNSDLL.BO.ORCID.REFRecordStatus.REFRecordStatuss.Waiting_for_ORCID_User_for_approval;
     personMessage.PersonID = person.PersonID;
     personMessage.RequestURL = ProfilesRNSDLL.BO.ORCID.Config.ORCID_API_URL_WITH_VERSION + "/" + person.ORCID + "/" + refPermission.MethodAndRequest;
     new BLL.ORCID.PersonMessage().Save(personMessage);
     return personMessage;
 }

 internal static void SetPersonMessageID(BO.ORCID.Person person)
 {
     if (person.Affiliations != null && person.Affiliations.Count > 0)
     {
         foreach (BO.ORCID.PersonAffiliation personAffiliation in person.Affiliations)
         {
             personAffiliation.PersonMessageID = person.PersonMessage.PersonMessageID;
         }
     }
 }

 internal static void SetPersonMessageID(BO.ORCID.Person person)
 {
     if (person.Othernames != null && person.Othernames.Count > 0)
     {
         foreach (BO.ORCID.PersonOthername personOthername in person.Othernames)
         {
             personOthername.PersonMessageID = person.PersonMessage.PersonMessageID;
         }
     }
 }

 internal static void SetPersonMessageID(BO.ORCID.Person person)
 {
     if (person.AlternateEmails != null && person.AlternateEmails.Count > 0)
     {
         foreach (BO.ORCID.PersonAlternateEmail personAlternateEmail in person.AlternateEmails)
         {
             personAlternateEmail.PersonMessageID = person.PersonMessage.PersonMessageID;
         }
     }
 }

 internal bool Save(BO.ORCID.PersonWorkIdentifier bo, System.Data.Common.DbTransaction trans)
 {
     if (bo.Exists)
     {
         return base.Edit(bo, trans);
     }
     else
     {
         return base.Add(bo, trans);
     }
 }

 public bool Save(BO.ORCID.PersonToken bo)
 {
     if (bo.Exists)
     {
         return base.Edit(bo);
     }
     else
     {
         return base.Add(bo);
     }
 }

 internal bool AddIfAny(BO.ORCID.Person person)
 {
     if (person.AlternateEmails != null)
     {
         foreach (BO.ORCID.PersonAlternateEmail altEmail in person.AlternateEmails)
         {
             altEmail.PersonID = person.PersonID;
             if (!this.Add(altEmail))
             {
                 return false;
             }
         }
     }
     return true;
 }

 internal bool AddIfAny(BO.ORCID.Person person)
 {
     if (person.Othernames != null)
     {
         foreach (BO.ORCID.PersonOthername otherName in person.Othernames)
         {
             otherName.PersonID = person.PersonID;
             if (!this.Add(otherName))
             {
                 return false;
             }
         }
     }
     return true;
 }

 public void CheckAlternateEmails(BO.ORCID.Person bo)
 {
     if (bo.AlternateEmails != null && bo.AlternateEmails.Count > 0)
     {
         foreach (BO.ORCID.PersonAlternateEmail email in bo.AlternateEmails)
         {
             if (!DevelopmentBase.RegEx.GeneralValidation.isValidEmail(email.EmailAddress))
             {
                 bo.HasError = true;
                 bo.AlternateEmailDecisionIDErrors += "Please check the email address as at least one is not valid. " + Environment.NewLine;
                 break;
             }
         }
     }
 }