Personnaliser la validation de l’envoi de formulaire

Article
12/31/2024

La validation côté client dans les formulaires de marketing et d’inscription à l’événement permet de garantir la validité des données soumises par le client. Cependant, dans certains cas, vous pouvez avoir besoin d’une validation plus complexe. Par exemple, vous devrez peut-être comparer les données envoyées avec les données déjà existantes dans votre système. Pour faciliter la validation complexe, cet article explique comment vous pouvez créer un plug-in personnalisé pour valider les données soumises sur le back-end et déclencher une logique de traitement des données supplémentaire.

Créer un plug-in

Note

Cet exemple de plug-in personnalisé montre comment créer une validation back-end pour la clé reCAPTCHA. Il peut servir d’inspiration pour votre flux de validation. Si vous souhaitez intégrer reCAPTCHA à votre formulaire, vous pouvez utiliser le plugin prédéfini et suivre ce guide.

Créer un projet Visual Studio pour le plug-in

Ouvrez Visual Studio et créez un projet de bibliothèque de classes à l’aide de .NET Framework 4.6.2.
Dans l’Explorateur de solutions, sélectionnez Gérer les packages NuGet et installez Microsoft.CrmSdk.CoreAssemblies.

Créer la classe de plug-in

Renommer Class1.cs en CustomValidationPlugin.cs.

Faites hériter la classe CustomValidationPlugin de l’interface IPlugin et ajoutez la méthode execute.

public class CustomValidationPlugin : IPlugin
{
   public void Execute(IServiceProvider serviceProvider)
   {

   }
}

Pour récupérer le contexte et le service de suivi, ajoutez le code suivant dans la méthode execute.

public void Execute(IServiceProvider serviceProvider)
{
   // get tracing service
   ITracingService tracingService =
   (ITracingService)serviceProvider.GetService(typeof(ITracingService));

   // get plugin execution context
   IPluginExecutionContext context = (IPluginExecutionContext)
   serviceProvider.GetService(typeof(IPluginExecutionContext));
}

Ajoutez ce code pour récupérer la chaîne du paramètre de soumission du formulaire. Il s’agit d’une chaîne codée JSON représentant les champs que l’utilisateur a soumis dans le formulaire. Ce processus récupère la chaîne et la désérialise à l’aide d’une méthode d’assistance de désérialisation et de la classe FormSubmissionRequest qui est définie ultérieurement. Ce code vérifie que le tableau fields contient une clé pour g-recaptcha-response. Si la clé reCAPTCHA est introuvable, il renvoie en ignorant la validation, car le formulaire en cours de traitement ne contenait pas d’élément recaptcha.
```
var requestString = (string)context.InputParameters["msdynmkt_formsubmissionrequest"];
var requestObject = Deserialize<FormSubmissionRequest>(requestString);
if (!requestObject.Fields.TryGetValue("g-recaptcha-response", out string recaptchaToken))
{
   tracingService.Trace("g-recaptcha-response was not present in form submission");
   return;
}
```

Ajoutez le code suivant à renvoyer si la valeur g-recaptcha-token est nulle ou vide.

if (String.IsNullOrEmpty(recaptchaToken))
{
   tracingService.Trace($"g-recaptcha-response value not found");
   return;
}

Ajoutez le code suivant pour valider le jeton captcha Google par rapport aux API Google.

string url = "https://www.google.com/recaptcha/api/siteverify";
using (HttpClient client = new HttpClient())
{
   var content = new FormUrlEncodedContent(new Dictionary<string, string>
   {
      {"secret", "your_secret_key"},
      {"response", recaptchaToken}
   });

   try
   {
      var response = client.PostAsync(url, content).Result;
      if (!response.IsSuccessStatusCode)
      {
         tracingService.Trace($"Request Failed: ({response.StatusCode}){response.Content}");
         return;
      }

      var responseString = response.Content.ReadAsStringAsync().Result;

      gRecaptchaResponse = Deserialize<GRecaptchaResponse>(responseString);

      var resp = new ValidateFormSubmissionResponse()
      {
         IsValid = isValid,
         ValidationOnlyFields = new List<string>() { "g-recaptcha-response" }
      };
      context.OutputParameters["msdynmkt_validationresponse"] = Serialize(resp);
    }
    catch (Exception e)
    {
       tracingService.Trace($"{e.Message}");
    }
}

Tout d’abord, l’URL est définie, puis une instance de HttpClient est créée. Un FormUrlEncodedContent objet est créé contenant le recaptchaToken récupéré lors des étapes précédentes et la clé secrète fournie par Google. Ensuite, une POST requête est envoyée et le code d’état est vérifié, s’il échoue, il est renvoyé. En cas de succès, il désérialise la réponse à l’aide de la méthode d’assistance deserialize et GRecaptchaResponse qui est définie ultérieurement. Il crée ensuite un nouvel ValidateFormSubmissionResponse objet, le sérialise et le définit comme valeur du paramètre de sortie msdynmkt_validationresponse, qui est le seul service Microsoft qu’il utilise pour accepter ou rejeter la soumission. L’ajout de la g-recaptcha-response chaîne à la ValidationOnlyFields liste masque ce champ de l’envoi du formulaire dans l’interface utilisateur.

Ajoutez le code suivant pour définir les méthodes d’assistance serialize et deserialize.

private T Deserialize<T>(string jsonString)
{
   serializer = new DataContractJsonSerializer(typeof(T));
   T result;
   using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(jsonString)))
   {
      result = (T)serializer.ReadObject(stream);
   }
   return result;
}

private string Serialize<T>(T obj)
{
    string result;
    serializer = new DataContractJsonSerializer(typeof(T));
    using (MemoryStream memoryStream = new MemoryStream())
    {
       serializer.WriteObject(memoryStream, obj);
       result = Encoding.Default.GetString(memoryStream.ToArray());
    }
    return result;
}

Ajoutez le code suivant pour définir les classes nécessaires pour sérialiser et désérialiser les objets de chaînes JSON.

public class FormSubmissionRequest
 {
     public Dictionary<string, string> Fields { get; set; }
 }

 public class GRecaptchaResponse
 {
     public bool success { get; set; }
 }

 public class ValidateFormSubmissionResponse
 {
     public bool IsValid { get; set; }
     public List<string> ValidationOnlyFields { get; set; }
 }

Signer et générer le plug-in

Cliquez avec le bouton de votre souris et sélectionnez de les Propriétairesdans Explorateur de solutions.
Sélectionnez l’onglet Signature et cochez Signer l’assembly.
Sélectionnez <New...>.
Entrez un nom de fichier de clé et désélectionnez Protéger mon fichier de clé avec un mot de passe.
Générez le projet.
Vous trouverez trouver l’assembly du plug-in CustomValidationPlugin.dll dans \bin\Debug.

Inscrire un plug-in

Ouvrir PluginRegistration.exe.
Cliquez sur Créer une connexion.
Choisissez Office 365.
Sélectionnez Connexion.
Cliquez sur Enregistrer, puis sur Enregistrer un assembly.
Sélectionnez le bouton (...) à l’étape 1 et sélectionnez la dll créée aux étapes précédentes.
Sélectionnez Inscrire un plug-in sélectionné.

Enregistrer une étape

Sélectionnez CustomValidationPlugin dans la liste des assemblys enregistrés.
Sélectionnez Inscrire une nouvelle étape.
Entrez msdynmkt_validateformsubmission dans le champ de texte du message.
Assurez-vous que le Mode d’exécution est défini sur Synchronous.
Assurez-vous que Ordre d’exécution est défini sur 10.
Vérifiez Phase d’exécution dans le pipeline d’événement est définie comme Opération postérieure
Sélectionnez Inscrire une nouvelle étape.

Conclusion

Quand un formulaire avec l’attribut data-validate-submission est envoyé, votre plug-in personnalisé s’exécute et valide la réponse reCAPTCHA avec les services Google. Le plug-in personnalisé s’exécute après le plug-in de validation Microsoft par défaut. S’il n’y a pas de champs captcha Microsoft dans le formulaire, le plug-in Microsoft définit IsValid:false et la soumission échoue à moins que vous ne l’écrasiez avec IsValid:true.

Partager via