Logo
Funções do schema
Funções do schemaEmail Sender

Email Sender

Included in the “Power Extensions” bundle

Envie emails via a mutation global _sendEmail.

Descrição

A mutation _sendEmail envia emails executando a função wp_mail do WordPress. Como resultado, ela utilizará a configuração definida para o envio de emails no WordPress (como o provedor SMTP a ser utilizado).

O email pode ser enviado com os tipos de conteúdo "text" ou "HTML", dependendo do valor do input messageAs (que é um InputObject "oneof", de modo que apenas uma de suas propriedades pode ser fornecida).

Para enviar como texto, forneça a propriedade messageAs.text:

mutation {
  _sendEmail(
    input: {
      to: "target@email.com"
      subject: "Email with text content"
      messageAs: {
        text: "Hello world!"
      }
    }
  ) {
    status
    errors {
      __typename
      ...on ErrorPayload {
        message
      }
    }
  }
}

Para enviar como HTML, forneça a propriedade messageAs.html:

mutation {
  _sendEmail(
    input: {
      to: "target@email.com"
      subject: "Email with HTML content"
      messageAs: {
        html: "<p>Hello world!</p>"
      }
    }
  ) {
    status
    errors {
      __typename
      ...on ErrorPayload {
        message
      }
    }
  }
}

Campo Global

_sendEmail é um campo global (ou, mais precisamente, uma mutation global). Isso significa que, se as Nested Mutations estiverem habilitadas, essa mutation pode ser executada em qualquer tipo do schema GraphQL (ou seja, não apenas em MutationRoot).

Isso é útil para iterar uma lista de usuários e enviar um email para cada um deles (neste caso, a mutation é acionada enquanto está no tipo User):

mutation {
  users {
    email
    _sendEmail(
      input: {
        to: $__email
        subject: "..."
        messageAs: {
          text: "..."
        }
      }
    ) {
    status
    errors {
      __typename
      ...on ErrorPayload {
        message
      }
    }
  }
}

Combinado com recursos de outras extensões (neste caso, Field to Input e PHP Functions via Schema), podemos criar mensagens personalizadas para cada usuário:

mutation {
  users {
    email
    displayName
    remainingCredits: metaValue(key: "credits")
    emailMessage: _sprintf(
      string: """
      <p>Hello %s!</p>
      <p>Your have <strong>%s remaining credits</strong> in your account.</p>
      <p><a href="%s">Buy more?</a></p>
      """,
      values: [
        $__displayName,
        $__remainingCredits,
        "https://mysite.com/buy-credits"
      ]
    )
    _sendEmail(
      input: {
        to: $__email
        subject: "Remaining credits"
        messageAs: {
          html: $__emailMessage
        }
      }
    ) {
      status
      errors {
        __typename
        ...on ErrorPayload {
          message
        }
      }
    }
  }
}

Capacidade necessária

A mutation pode ser restrita a usuários que possuem uma capacidade específica do WordPress. Essa configuração é definida na página de Configurações, em Plugin Configuration > Email Sender.

Configurando a capacidade necessária para o Email Sender
Configurando a capacidade necessária para o Email Sender

O padrão é manage_options para que assinantes não possam usar a mutation para enviar spam a destinatários arbitrários.

Selecione (any logged-in user) para desabilitar a verificação de capacidade.

Mais exemplos

A query abaixo envia um email ao usuário administrador com o conteúdo de um post (por exemplo: pode ser acionada sempre que um novo post for publicado). Ela utiliza as extensões:

  • Multiple Query Execution para organizar a query em unidades lógicas
  • Helper Function Collection para compor a mensagem do email usando Markdown e convertê-la em HTML via _strConvertMarkdownToHTML
  • PHP Functions via Schema para injetar dinamicamente valores no assunto e na mensagem do email via os campos _strReplaceMultiple e _sprintf
  • Field to Input para recuperar e fornecer o email do administrador a partir do wp_options
query GetPostData($postID: ID!) {
  post(by: {id: $postID}) {
    title @export(as: "postTitle")
    excerpt @export(as: "postExcerpt")
    url @export(as: "postLink")
    author {
      name @export(as: "postAuthorName")
      url @export(as: "postAuthorLink")
    }
  }
}
 
query GetEmailData @depends(on: "GetPostData") {
  emailMessageTemplate: _strConvertMarkdownToHTML(
    text: """
 
There is a new post by [{$postAuthorName}]({$postAuthorLink}):
 
**{$postTitle}**: {$postExcerpt}
 
[Read online]({$postLink})
 
    """
  )
  emailMessage: _strReplaceMultiple(
    search: ["{$postAuthorName}", "{$postAuthorLink}", "{$postTitle}", "{$postExcerpt}", "{$postLink}"],
    replaceWith: [$postAuthorName, $postAuthorLink, $postTitle, $postExcerpt, $postLink],
    in: $__emailMessageTemplate
  )
    @export(as: "emailMessage")
  subject: _sprintf(string: "New post created by %s", values: [$postAuthorName])
    @export(as: "emailSubject")
}
 
mutation SendEmail @depends(on: "GetEmailData") {
  adminEmail: optionValue(name: "admin_email")
  _sendEmail(
    input: {
      to: $__adminEmail
      subject: $emailSubject
      messageAs: {
        html: $emailMessage
      }
    }
  ) {
    status
  }
}