Compartilhar via

Personalizar validação do envio de formulário

  • Artigo

A validação do lado do cliente em formulários de marketing e registro de evento ajuda a garantir a validade dos dados enviados pelo cliente. No entanto, em alguns casos, talvez você precise de uma validação mais complexa. Por exemplo, talvez você precise comparar dados enviados com os dados já existentes no sistema. Para facilitar a validação complexa, este artigo detalha como você pode compilar um plug-in personalizado para validar os dados enviados no back-end e disparar a lógica do processamento de dados extra.

Criar um plug-in

Observação

Este exemplo de plug-in personalizado mostra como compilar uma validação de back-end para a chave reCAPTCHA. Ele pode funcionar como inspiração para o fluxo de validação. Se quiser integrar o reCAPTCHA ao formulário, você poderá usar o plug-in pré-compilado e seguir este guia.

Criar um projeto do Visual Studio para o plug-in

  1. Abra o Visual Studio e crie um projeto da biblioteca de classes usando o .NET Framework 4.6.2.
  2. No Gerenciador de Soluções, selecione Gerenciar Pacotes NuGet e instale Microsoft.CrmSdk.CoreAssemblies.

Crie a classe do plug-in

  1. Renomeie Class1.cs para CustomValidationPlugin.cs.

  2. Faça a classe CustomValidationPlugin herdar da interface IPlugin e adicione o método de execução.

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

   }
}

  3. Para recuperar o contexto e o serviço de acompanhamento, adicione o código a seguir ao método de execução.

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

  4. Adicione este código para recuperar a cadeia de caracteres do parâmetro de envio de formulário. É uma cadeia de caracteres codificada em JSON que representa os campos que o usuário enviou no formulário. Esse processo recupera a cadeia de caracteres e a desserializa usando um método auxiliar de desserialização e a classe FormSubmissionRequest definida posteriormente. Esse código verifica se a matriz de campos contém uma chave para g-recaptcha-response. Se não for encontrada, a chave reCAPTCHA retornará ignorando a validação, pois o formulário que está processando não tinha 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;
}

  5. Adicione o código a seguir para retornar se o valor g-recaptcha-token for nulo ou vazio.

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

  6. Adicione o código a seguir para validar o token captcha do Google em relação às APIs do 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, a URL é definida, então uma instância de HttpClient é criada. Um objeto FormUrlEncodedContent é criado contendo o recaptchaToken recuperado nas etapas anteriores e a chave secreta fornecida pelo Google. Então, uma solicitação POST é enviada e o código de status é verificado, se não for bem-sucedido, ele retorna. Se for bem-sucedido, ele desserializa a resposta usando o método auxiliar de desserialização e GRecaptchaResponse, que será definido posteriormente. Em seguida, ele cria um objeto ValidateFormSubmissionResponse, o serializa e o define como o valor do parâmetro de saída msdynmkt_validationresponse, que é o único serviço da Microsoft usado para aceitar ou rejeitar o envio. A adição da cadeia de caracteres g-recaptcha-response à lista ValidationOnlyFields oculta esse campo do envio do formulário na interface do usuário.

  7. Adicione o código a seguir para definir os métodos auxiliares de serialização e desserializaçã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;
}

  8. Adicione o código a seguir para definir as classes necessárias para serializar e desserializar 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

  1. Clique com o botão direito do mouse no projeto e selecione Propriedades no Gerenciador de Soluções.
  2. Selecione a guia Assinatura e marque a caixa de seleção Assinar o assembly.
  3. Selecione <New...>.
  4. Insira um nome de arquivo de chave e desmarque Proteger meu arquivo de chave com uma senha.
  5. Crie o projeto.
  6. Você pode encontrar o assembly do plug-in CustomValidationPlugin.dll em \bin\Debug.

Registrar plug-in

  1. Abra PluginRegistration.exe.
  2. Selecione Criar conexão.
  3. Escolha Office 365.
  4. Selecione Logon.
  5. Selecione Registrar e, depois, Registrar novo assembly. Selecione Registrar e, depois, Registrar novo assembly.
  6. Selecione o botão (...) na etapa 1 e selecione a dll criada nas etapas anteriores.
  7. Selecione Registrar plug-in selecionado.

Registrar etapa

  1. Selecione CustomValidationPlugin na lista de assemblies registrados.
  2. Selecione Registrar Nova Etapa.
  3. Insira msdynmkt_validateformsubmission no campo de texto da mensagem.
  4. Certifique-se de que Modo de Execução esteja definido como Síncrono. Certifique-se de que Modo de Execução esteja definido como Síncrono.
  5. Verifique se Ordem de execução está definida como 10.
  6. Certifique-se de que Etapa de Execução do Pipeline de Eventos esteja definido como Após a Operação.
  7. Selecione Registrar Nova Etapa.

Conclusão

Quando um formulário com o atributo data-validate-submission é enviado, seu plug-in personalizado é executado e valida a resposta reCAPTCHA com os serviços do Google. O plug-in personalizado será executado depois do plug-in de validação Microsoft padrão. Se não houver campos captcha da Microsoft no formulário, o plug-in da Microsoft definirá IsValid:false e o envio falhará, a menos que você o substitua por IsValid:true.

Fluxo de validação.