Validierung der Formularübermittlung anpassen

Artikel
12/27/2024

Die clientseitige Validierung in Marketing- und Veranstaltungsregistrierungsformularen trägt dazu bei, die Gültigkeit der vom Kunden übermittelten Daten sicherzustellen. In einigen Fällen ist jedoch möglicherweise eine komplexere Validierung erforderlich. Beispielsweise müssen Sie möglicherweise übermittelte Daten mit den bereits in Ihrem System vorhandenen Daten vergleichen. Um die komplexe Validierung zu vereinfachen, wird in diesem Artikel beschrieben, wie Sie ein benutzerdefiniertes Plug-In erstellen können, um die übermittelten Daten im Backend zu validieren und zusätzliche Datenverarbeitungslogik auszulösen.

Ein Plug-In erstellen

Anmerkung

Dieses Beispiel für ein benutzerdefiniertes Plug-In zeigt, wie Sie eine Back-End-Validierung für den reCAPTCHA-Schlüssel erstellen. Dies kann als Inspiration für Ihren Validierungsablauf dienen. Wenn Sie reCAPTCHA in Ihr Formular integrieren möchten, können Sie das vorgefertigte Plugin verwenden und dieser Anleitung folgen.

Erstellen Sie ein Visual Studio-Projekt für das Plug-In

Öffnen Sie Visual Studio und erstellen Sie ein neues Klassenbibliotheksprojekt mithilfe von .NET Framework 4.6.2.
Wählen Sie im Lösungsexplorer NuGet-Pakete verwalten aus und installieren Sie Microsoft.CrmSdk.CoreAssemblies.

Erstellen Sie die Plug-In-Klasse

Benennen Sie Class1.cs in CustomValidationPlugin.cs um.
Lassen Sie die CustomValidationPlugin-Klasse von der IPlugin-Schnittstelle erben und fügen Sie die Methode zum Ausführen hinzu.
```
public class CustomValidationPlugin : IPlugin
{
   public void Execute(IServiceProvider serviceProvider)
   {

   }
}
```

Fügen Sie der execute-Methode den folgenden Code hinzu, um den Kontext und den Ablaufverfolgungsdienst abzurufen.

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));
}

Fügen Sie diesen Code hinzu, um die Parameterzeichenfolge für die Formularübermittlung abzurufen. Es ist eine JSON-codierte Zeichenfolge, die die Felder darstellt, die der Benutzer im Formular übermittelt hat. Dieser Prozess ruft die Zeichenfolge ab und deserialisiert sie mithilfe einer deserialize-Hilfsmethode und der FormSubmissionRequest-Klasse, die später definiert wird. Dieser Code überprüft, ob das fields-Array einen Schlüssel für g-recaptcha-response enthält. Wenn der reCAPTCHA-Schlüssel nicht gefunden wird, wird die Validierung übersprungen, da das verarbeitete Formular kein recaptcha-Element enthielt.
```
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;
}
```

Fügen Sie den folgenden Code hinzu, um zurückzukehren, wenn der g-recaptcha-token Wert null oder leer ist.

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

Fügen Sie den folgenden Code hinzu, um das Google-Captcha-Token anhand von Google-APIs zu prüfen.
```
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}");
    }
}
```
Zuerst wird die URL definiert, dann wird eine Instanz von HttpClient erstellt. Ein FormUrlEncodedContent-Objekt wird erstellt, das den recaptchaToken, der in vorherigen Schritten abgerufen wurde, und den geheimen Schlüssel enthält, der von Google bereitgestellt wird. Dann wird eine POST-Anforderung gesendet und der Statuscode wird überprüft. Ist dies nicht erfolgreich, wird sie zurückgegeben. Bei erfolgreicher Prüfung wird die Antwort mit der Deserialisierungs-Hilfsmethode und der später definierten GRecaptchaResponse deserialisiert. Anschließend wird ein neues ValidateFormSubmissionResponse-Objekt erstellt, serialisiert und es wird als Wert des Ausgabeparameters msdynmkt_validationresponse festgelegt. Dabei handelt es sich um den einzigen Microsoft-Dienst, den es verwendet, um die Übermittlung anzunehmen oder abzulehnen. Wenn Sie die g-recaptcha-response Zeichenfolge zur ValidationOnlyFields Liste hinzufügen, wird dieses Feld vor der Formularübermittlung in der Benutzeroberfläche ausgeblendet.

Fügen Sie den folgenden Code hinzu, um die Serialisierungs- und Deserialisierungs-Hilfsmethoden zu definieren.

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;
}

Fügen Sie den folgenden Code hinzu, um die Klassen zu definieren, die zum Serialisieren und Deserialisieren von JSON-Zeichenfolgenobjekten erforderlich sind.

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; }
 }

Signieren Sie das Plug-In und erstellen Sie es

Klicken Sie mit der rechten Maustaste auf das Projekt und wählen Sie Eigenschaften im Lösungs-Explorer aus.
Wählen Sie die Registerkarte Signieren aus und aktivieren Sie dann das Kontrollkästchen Assembly signieren.
Wählen Sie <New...> aus.
Geben Sie einen Schlüsseldateinamen ein und heben Sie die Auswahl für Meine Schlüsseldatei mit einem Kennwort schützen auf.
Erstellen Sie das Projekt.
Sie finden die Plug-In-Assembly CustomValidationPlugin.dll in \bin\Debug.

Registrieren Sie das Plug-In

Öffnen Sie PluginRegistration.exe.
Wählen Sie Neue Verbindung erstellen aus.
Wählen Sie Office 365 aus.
Wählen Sie Anmeldung aus.
Wählen Sie Registrieren und dann Neue Assembly registrieren aus.
Wählen Sie in Schritt 1 die Schaltfläche (...) und dann die in den vorherigen Schritten erstellte DLL aus.
Wählen Sie Ausgewähltes Plug-In registrieren aus.

Registrieren Sie den Schritt

Wählen Sie CustomValidationPlugin aus der Liste der registrierten Assemblys aus.
Wählen Sie Neuen Schritt registrieren aus.
Geben Sie msdynmkt_validateformsubmission in das Meldungstextfeld ein.
Stellen Sie sicher, dass Ausführungsmodus auf Synchron eingestellt ist.
Stellen Sie sicher, dass die Ausführungsreihenfolge auf 10 eingestellt ist.
Stellen Sie sicher, dass Ereignis-Pipeline-Phase der Ausführung auf Nach Vorgang eingestellt ist.
Wählen Sie Neuen Schritt registrieren aus.

Schlussfolgerung

Wenn ein Formular mit dem Attribut data-validate-submission übermittelt wird, wird Ihr benutzerdefiniertes Plug-In ausgeführt und die reCAPTCHA-Antwort wird mit Google-Diensten überprüft. Das benutzerdefinierte Plug-In wird nach dem standardmäßigen Microsoft-Validierungs-Plug-In ausgeführt. Wenn das Formular keine Microsoft-Captcha-Felder enthält, legt das Microsoft-Plug-In IsValid:false fest und die Übermittlung schlägt fehl, es sei denn, Sie überschreiben es mit IsValid:true.

Freigeben über