Lucas Teixeira

Hum, reportando uma situação no mínimo inusitada que tive por aqui.

Acabei descobrindo, da maneira ruim, que no Grails, quando lêmos a configuração da aplicação (Config.groovy) através da referência grailsApplication.config estamos manipulando uma variável passível de alterações, ou seja, qualquer atributo que você recuperar de lá, e modificar, assim estará para toda a execução.

Na minha situação, eu mantinha uma lista de e-mails lá no arquivo de configuração para que quando disparado, eu pudesse enviar o e-mail a estes destinatários somados ao e-mail do usuário, que tinha acabado de ser inputado no formulário. Tinha algo assim:

contato.destinatarios = ["email1@xpto.com", "email2@xpto.com", "email3@xpto.com"]

E dentro do controller, usando o mail plugin (leia este post sobre o mail plugin), executava o seguinte trecho de código:

def destinatarios = grailsApplication.config.contato?.destinatarios?.toArray()
destinatarios << params.email
sendMail {
    to destinatarios
    subject "Contato ..."
    body "......"
 }

Ou seja, quando eu pegava a referência dos destinatários do Config, eu mantinha essa referência em ‘destinatários’. Quando eu adicionava neste array o destinatário que vinha do formulários “params.email”, eu alterava a *instância* e referência da configuração da aplicação, e aquele e-mail ali ficava.

Resultado, no primeiro contato, receberam o e-mail a lista de destinatários e o primeirocontato@xpto.com, na segunda execução, todos eles da configuração, o primeirocontato@xpto.com e também o segundocontato@xpto.com foram copiados.

E assim sucessivamente.

Vivendo e aprendendo, tomem cuidado com isso!

Ontem (dia 09/01) fizemos o lançamento de um site que desenvolvemos usando Groovy e Grails, um desafio e tanto, pela responsabilidade de colocar o sistema no ar e pelo timing do projeto. Todo o site e a integração com o sistema legado (onde algumas informações ainda estão sendo gerenciadas), tiveram que sair do simples “create app” para produção em 2 meses. Esse é também o grande motivo para a falta de tempo de postar mais por aqui.

Trata-se dos sites http://www.imoveisnomorumbi.com.br e http://www.imoveisnopanamby.com.br, site de duas imobiliárias do mesmo grupo, que negocia imóveis de alto padrão nestes dois bairros.

Algumas informações interessantes sobre o projeto:

Tecnologia e Infraestrutura: O site antigo usava SQLServer como banco de dados e tecnologia ASP. Como usamos Groovy e Grails, por trás temos uma JVM Java em execução, e o banco de dados, o bom e velho MySQL.

Antes, para suportar o ASP, o IIS era usado como web server, e agora Um apache balanceia as requisições aos dois Tomcats. Tudo isto está deployado e rodando em um Cloud Server da Locaweb, por opção do cliente, onde já mantinha a conta antiga.

Integração com o sistema legado: Para a integração do modelo de dados antigo e o novo modelo, construímos rotinas de importação dos dados usando Groovy SQL, uma maneira  fácil, muito fácil, de fazer rotinas em banco de dados.

Plugins utilizados: Ahhh, os bons e velhos plugins do Grails, não canso de dizer que esta é a melhor parte do Grails! Foram usados os plugins:

Grails-Mail, para envio dos e-mails e formas de contato do site
Grails-Acegi, para autenticação e segurança
Grails-Cookie, para manipulação dos cookies do cliente
Grails-Navigation para criação de menus/submenus da interface administrativa
Grails-RichUi para alguns componentes gráficos como auto-complete e nuvem de tags
Grails-RuntimeLogging, um ótimo plugin para moder trabalhar com o nível de log de cada artefato (controller, service, etc), da app em runtime
Grails-Settings para algumas parametrizações da aplicação.

E com certeza, se eu tivesse pesquisado com um pouco mais de tempo, teria usado outros plugins para evitar algum trabalho que tenha feito na mão. E é claro, além disso, bastante (mesmo) jquery, ajax e json.

É isso, qualquer dúvida sobre o projeto, como aconteceu, soluções e problemas, basta comentar!

Obrigado a todos!

Enviar e-mails a partir de uma aplicação Grails é extremamente fácil. Tudo graças ao Mail Plugin. Sou um grande fã do mecanismo de plugins do Grails não só pela facilidade de criá-los, mas principalmente pelo espírito de compartilhamento de código que isto gera nos desenvolvedores. É bem simples, por exemplo, se eu preciso de alguma coisa que envie e-mails, vou construir isto separado da minha aplicação e distribuir para todos que precisem. Fácil, muito fácil!

Enfim, o Mail Plugin é um dos plugins mais antigos do Grails (acho que usei pela primeira vez em agosto de 2008), e um dos mais simples de ser usado. O primeiro passo é instalar o plugin como qualquer outro:

grails install-plugin mail

Com isso as dependências serão baixadas e o plugin será instalado.

Após isso, você vai precisar configurar o envio de e-mail.
De forma bem intuitiva novamente, diretamente em seu Config.groovy deverá setar as propriedades:

grails {
   mail {
      host     = "smtp.meuservidor.com.br"
      port     = 25
      username = "usuario@provedor.com.br"
      password = "eusoul33t"
      props    = ["mail.smtp.auth": "true", "mail.smtp.socketFactory.port": "587"]
   }
}

Ahhh, o exemplo acima já está pronto para usar validação de usuário e senha no envio, já que hoje (99%) dos servidores assim exigem. Pronto, com isso o plugin já consegue saber como o e-mail será enviado (por trás ele usa o envio de e-mails embutido no Spring, é claro).

Agora, quando for enviar um e-mail, basta usar a closure sendMail que é automaticamente adicionada em todos os seus controllers! Segue um exemplo:

sendMail {
   from "lucas@testedoblog.com.br"
   to "dest1@email.com", "dest2@email.com"
   cc "copia@email.com"
   bcc "oculto@email.com"
   subject "Enviando e-mails com Grails"
   body """
      E ai pessoal,
      Este e-mail foi enviado diretamente de um controller da minha
      aplicação Grails usando o Mail Plugin.

      Até mais."""
}

Pronto, agora é só checar as caixas de e-mail! Vale lembrar que as instruções cc e bcc não são obrigatórias!

O plugin suporta envio de anexos, conteúdo HTML e outras opções. Para mais detalhes, consulte a documentação oficial, ou deixe um comentário aqui.

Ahh, e se quiser usar uma caixa do GMail para enviar as mensagens, use a configuração abaixo.

grails {
   mail {
      host     = "smtp.gmail.com"
      port     = 465
      username = "seulogingmail@gmail.com"
      password = "suasenhadogmail"
      props    = ["mail.smtp.auth": "true",
                  "mail.smtp.socketFactory.port": "465",
                  "mail.smtp.socketFactory.class": "javax.net.ssl.SSLSocketFactory",
                  "mail.smtp.socketFactory.fallback": "false"]
   }
}

Feliz 2010, ao som de “Dream Theater – Don’t look past me”.

Primeiro post do meu blog totalmente em português!

Esta semana, precisei adicionar na aplicação a funcionalidade de enviar e-mails usando templates do Velocity para o corpo do e-mail. Claro que o poderíamos usar o arroz com feijão do Velocity para isso, fazendo o merge do template com nosso contexto de variáveis, mas acabei esbarrando em um site, e descobri que o próprio Spring já possui um FactoryBean para a criação do meu VelocityEngine além de também ficar responsável com o carregamento dos templates (na minha opinião, a parte mais chata).

Bom, explicando brevemente como resolvi o problema:

• Bean VelocityEngineFactoryBean

Defini este bean no applicationContext.xml para controlar a injeção do VelocityEngine

<bean id="velocityEngine" class="org.springframework.ui.velocity.VelocityEngineFactoryBean">
  <property name="resourceLoaderPath" value="/WEB-INF/templates/" />
</bean>

Notem que a propriedade resourceLoaderPath já é definida ali, e é neste diretório indicado que os templates deverão estar.

• Bean JavaMailSenderImpl

Este bean do core do spring já encapsula o envio da mensagem, neste exemplo, está configurado com estas propriedades que vieram de um arquivo de propriedades que carreguei no início do meu applicationContext.xml

<bean id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
  <property name="host" value="${mail.smtp.host}" />
  <property name="username" value="${mail.smtp.user}" />
  <property name="password" value="${mail.smtp.pass}" />
  <property name="port" value="${mail.smtp.port}" />
</bean>

• Bean SimpleMailMessage

Este é o bean que será o template da mensagem. É um “modelo” de mensagem, que carrega o endereço ‘from’ e também o subject do e-mail do mesmo arquivo de configuração.

<bean id="templateMailMessage" class="org.springframework.mail.SimpleMailMessage">
  <property name="from" value="${mail.from}" />
  <property name="subject" value="${mail.subject}" />
</bean>

Com isso, já tenho os 3 beans que serão injetados em meu componente de envio de e-mails.

• Template velocity do e-mail

O template que eu criei para o teste é bem simples e segue abaixo. Se chama mail.vm e como dito ali em cima, está dentro de /WEB-INF/templates/

Oi ${nome}, seu e-mail (${email}) foi cadastrado no sistema.

• Componente final para o envio do e-mail

Chamei o componente de MailComponent (bem criativo, né?), e a única coisa que ele faz, é receber os beans que definimos via injeção, criar uma nova mensagem usando o template de e-mails e setar como body da mensagem o resultado do merge entre o template e as minhas variáveis. Segue o código do componente.

import java.util.HashMap;
import java.util.Map;

import org.apache.velocity.app.VelocityEngine;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mail.MailSender;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.stereotype.Component;
import org.springframework.ui.velocity.VelocityEngineUtils;

@Component
public class MailComponent {

  @Autowired
  private MailSender mailSender;

  @Autowired
  private SimpleMailMessage templateMailMessage;

  @Autowired
  private VelocityEngine velocityEngine;

  public void sendMail(String template, Stirng nome, String email, String ... to) {

    Map<String, Object> ctx= new HashMap<String, Object>() {{
      put("nome", nome);
      put("email", email);
    }};

    String body = VelocityEngineUtils.mergeTemplateIntoString(velocityEngine, template, ctx);
    SimpleMailMessage msg = new SimpleMailMessage(this.templateMailMessage);
    msg.setTo(to);
    msg.setText(body);

    mailSender.send(msg);
  }
}

Pronto, o componente está pronto, agora a qualquer momento, em qualquer classe (que tenha acesso ao contexto de DI do spring é claro) você poderá chamar o seu componente

@Autowired
private MailComponent mailComponent

E enviar os e-mails aos usuários:

//Envia e-mail para o usuário com cópia ao admin
mailComponent.sendMail("mail.vm", "Lucas", "mail@mail.org", "mail@mail.org", "admin@site.org");

É isso aí.

[]s,