Personalizar validação de envio de formulário

Artigo
12/27/2024

A validação do lado do cliente em formulários de marketing e registo de eventos ajuda a garantir a validade dos dados submetidos pelo cliente. No entanto, em alguns casos, pode ser necessária uma validação mais complexa. Por exemplo, pode ser necessário comparar os dados enviados com os dados já existentes no seu sistema. Para facilitar a validação complexa, este artigo detalha como pode criar um plug-in personalizado para validar os dados enviados no back-end e acionar a lógica de processamento de dados extra.

Criar um plug-in

Nota

Este exemplo de plug-in personalizado mostra como criar validação de back-end para a chave reCAPTCHA. Pode servir de inspiração para o seu fluxo de validação. Se quiser integrar o reCAPTCHA ao seu formulário, pode usar o plug-in pré-criado e seguir este guia.

Criar um projeto do Visual Studio para o plug-in

Abra o Visual Studio e crie um novo projeto da biblioteca de classes utilizando o .NET framework 4.6.2.
No Explorador de Soluções, selecione Gerir Pacotes NuGet e instale o Microsoft.CrmSdk.CoreAssemblies.

Criar a classe do plug-in

Mudar o nome de Class1.cs para CustomValidationPlugin.cs.

Faça com que a classe CustomValidationPlugin herde da interface IPlugin e adicione o método executar.

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

   }
}

Para obter o contexto e o serviço de rastreamento, adicione o seguinte código ao método executar.

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

Adicione este código para obter a cadeia do parâmetro de submissão do formulário. É uma cadeia codificada JSON que representa os campos que o utilizador submeteu no formulário. Este processo obtém a cadeia de caracteres e a anula a serialização usando um método auxiliar de anulação da serialização e a classe FormSubmissionRequest que é definida posteriormente. Este código verifica se a matriz campos contém uma chave para g-recaptcha-response. Se a chave reCAPTCHA não for encontrada, ignora a validação, pois o formulário que está a processar não continha um elemento 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;
}
```

Adicione o seguinte código para devolução se o valor g-recaptcha-token for nulo ou vazio.

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

Adicione o código que se segue para validar o token de captcha da Google em relação às APIs 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}");
    }
}

Primeiro, o URL é definido e, em seguida, é criada uma instância do HttpClient. É criado um objeto FormUrlEncodedContent que contém o recaptchaToken obtido nos passos anteriores e a chave secreta fornecida pela Google. Em seguida, é enviado um pedido POST e o código de estado é verificado, caso não tenha êxito, é devolvido. Se tiver êxito, anula a serialização da resposta utilizando o método de assistente de anular serialização e a GRecaptchaResponse que é definida posteriormente. De seguida, criar um novo objeto ValidateFormSubmissionResponse, serializa-o e define-o como o valor do parâmetro de saída msdynmkt_validationresponse, que é o serviço da Microsoft que utiliza para aceitar ou rejeitar a submissão. Adicionar a cadeia (de carateres) g-recaptcha-response à lista ValidationOnlyFields oculta este campo do envio do formulário na interface do utilizador.

Adicione o código que se segue para definir os métodos de assistente serializar e anular a serialização.

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

Adicione o código seguinte para definir as classes necessárias para serializar e anular a serialização de objetos de cadeias de caracteres 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; }
 }

Assinar e compilar o plug-in

Clique com o botão direito do rato no projeto e selecione Propriedades no Explorador de Soluções.
Selecione o separador Assinatura e marque a caixa de verificação Assinar a assemblagem.
Selecione <New...>.
Introduza um nome de ficheiro-chave e desselecione Proteger o meu ficheiro-chave com uma palavra-passe.
Compilar o projeto.
Pode encontrar a assemblagem do plug-in CustomValidationPlugin.dll em \bin\Debug.

Registar plug-in

Abrir PluginRegistration.exe.
Selecione Criar nova ligação.
Escolha Office 365.
Selecione Iniciar sessão.
Selecione Registar e, em seguida, Registar nova assemblagem.
Selecione o botão (...) no passo 1 e selecione o dll incorporado nos passos anteriores.
Selecione Registar plug-in selecionado.

Registar passo

Selecione CustomValidationPlugin da lista de assemblagens registadas.
Selecione Registar Novo Passo.
Introduzir msdynmkt_validateformsubmission no campo de mensagem de texto.
Certifique-se de que o Modo de Execução está definido como Síncrono.
Certifique-se de que a Ordem de execução está definida como 10.
Certifique-se de que a Fase do Pipeline do Evento da Execução está definido como Após a Operação.
Selecione Registar Novo Passo.

Conclusão

Quando um formulário com o atributo data-validate-submission é submetido, o seu plug-in personalizado é executado e valida a resposta do reCAPTCHA com serviços da Google. O plug-in personalizado é executado após o plug-in de validação predefinido da Microsoft. Se não houver campos captcha da Microsoft no formulário, o plug-in da Microsoft define IsValid:false e a submissão falha, a menos que o substitua por IsValid:true.

Partilhar via