Testando Endpoints

Após criado a classe do endpoint, para que ela seja acessível, deve ser mapeada no web.xml, conforme abaixo:

        <servlet>
<servlet-name>SystemServiceServlet</servlet-name>
<servlet-class>com.google.api.server.spi.SystemServiceServlet</servlet-class>
<init-param>
<param-name>services</param-name>
<param-value>
br.com.super2.endpoint.ProjectEndpoint,
br.com.super2.endpoint.TaskEndpoint,
br.com.super2.endpoint.DiscussionEndpoint
</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>SystemServiceServlet</servlet-name>
<url-pattern>/_ah/spi/*</url-pattern>
</servlet-mapping>


Ao executar o projeto, estar disponível a seguinte url: localhost:8888/_ah/api/explorer
Onde sera possível realizar os testes de todos os métodos do endpoint.

Criar endpoints com Google Cloud Endpoints

Após criado o projeto, criar a classe do endpoint com as anotações conforme abaixo. Onde:
@Api(name = "exampleProject") é o nome da aplicação
@ApiMethod(name =  "customers.list",, httpMethod = HttpMethod.GET) - é o nome do serviço


@Api(name = "exampleProject")
public class CustomerEndpoint {

private static final String ENTIDADE = "Cliente";

@ApiMethod(name =  "customers.list",, httpMethod = HttpMethod.GET)
public CollectionResponse<Customer> listCustomer() throws Exception {
try {
List<Customer> list = Customer.getDao().list();
return CollectionResponse.<Customer> builder().setItems(list).build();
} catch (Exception e) {
throw new Exception(String.format(Message.ERRO_LIST, ENTIDADE));
}
}

@ApiMethod(name = "customers.get", httpMethod = HttpMethod.GET)
public Customer getCustomer(@Named("id") Long id) throws Exception {
try {
return Customer.getDao().get(id);
} catch (Exception e) {
throw new Exception(String.format(Message.ERRO_GET, ENTIDADE));
}
}

@ApiMethod(name = "customers.insert", httpMethod = HttpMethod.POST)
public Customer insertCustomer(Customer model) throws Exception {
try {
return Customer.getDao().insert(model);
} catch (Exception e) {
throw new Exception(String.format(Message.ERRO_INSERT, ENTIDADE));
}
}

@ApiMethod(name = "customers.update", httpMethod = HttpMethod.PUT)
public Customer updateCustomer(Customer model) throws Exception {
try {
return Customer.getDao().update(model);
} catch (Exception e) {
throw new Exception(String.format(Message.ERRO_UPDATE, ENTIDADE));
}
}

@ApiMethod(name = "customers.remove", httpMethod = HttpMethod.DELETE)
public void removeCustomer(@Named("id") Long id) throws Exception {
try {
Customer.getDao().delete(id);
} catch (Exception e) {
throw new Exception(String.format(Message.ERRO_REMOVE, ENTIDADE));
}
}

Acesso a banco via Hibernate

Para buscar a sessão responsável por executar o acesso ao banco, foi criado uma classe da seguinte forma:

import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;

public class HibernateUtil {

 private static final SessionFactory sessionFactory;
 static {
  try {
   // Create the SessionFactory from hibernate.cfg.xml
   sessionFactory = new AnnotationConfiguration().configure()
     .buildSessionFactory();
  } catch (Throwable ex) {
   // Make sure you log the exception, as it might be swallowed
   System.err.println("Initial SessionFactory creation failed." + ex);
   throw new ExceptionInInitializerError(ex);
  }
 }

 public static SessionFactory getSessionFactory() {
  return sessionFactory;
 }
}

E para realizar o acesso, basta chama-la da seguinte forma:

public class UserDaoImpl implements UserDao {

 private Session session;

 public void salvar(User user) {
  session = HibernateUtil.getSessionFactory().openSession();
  session.beginTransaction();
  session.save(user);
  session.getTransaction().commit();
 }

 public List listar() {
  session = HibernateUtil.getSessionFactory().openSession();
  session.beginTransaction();
  List userList = session.createQuery("from User").list();
  session.getTransaction().commit();
  return userList;
 }

E então resta apenas utilizar de forma simples:

  User c1 = new User();
  c1.setNome("Raul Seixas");  

  User c2 = new User();
  c2.setNome("Bruce Dickinson");

  UserDao clienteDAO = new UserDaoImpl();
  clienteDAO.salvar(c1);
  clienteDAO.salvar(c2);

Utilizando @SequenceGenerator do hibernate com o Firebird

Para utilizar Sequence do firebird, basta criar o generator no banco de dados:

"CREATE SEQUENCE GEN_USUARIO_ID;"

E depois disso, utilizar este nome na entidade, mapeando da seguinte forma:

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.SequenceGenerator;
import javax.persistence.Table;

@Entity
@SequenceGenerator(name = "INC_USUARIO", sequenceName = "GEN_USUARIO_ID")
@Table(name = "usuario")
public class User {

  @Id
  @GeneratedValue(strategy = GenerationType.AUTO, generator = "INC_USUARIO")
  private Long id;

  @Column
  private String nome;

E o mapeamento do arquivo hibernate.cfg.xml fica normal.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
 <session-factory name="Hibernate" >
  <!-- Database connection settings -->
  <property name="connection.driver_class">org.firebirdsql.jdbc.FBDriver</property>
  <property name="connection.url">jdbc:firebirdsql:localhost/3050:E:\Desenv\Base\base.fdb</property>
  <property name="connection.username">sysdba</property>
  <property name="connection.password">masterkey</property>
  <!-- JDBC connection pool (use the built-in) -->
  <property name="connection.pool_size">1</property>
  <!-- SQL dialect -->
  <property name="dialect">org.hibernate.dialect.FirebirdDialect</property>
  <!-- Enable Hibernate's automatic session context management -->
  <property name="current_session_context_class">thread</property>
  <!-- Disable the second-level cache -->
  <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
  <!-- Echo all executed SQL to stdout -->
  <property name="show_sql">true</property>
  
  <!-- property name="hibernate.hbm2ddl.auto">create</property> -->

  <mapping class="br.com.viartes.entities.User" />
 </session-factory>
</hibernate-configuration>

Grupo de JSF oficial do Brasil!

Um grupo internacional da língua portuguesa para discussão de conceitos e tecnologias Web como JavaServer Faces, RIA, patterns e ferramentas de desenvolvimento.

Grupo de JSF

PartialRefresh e Partialtriggers para componentes ADF

Para que serve?
Atualizar componentes sem que seja preciso atualizar a pagina.

PartialRefresh
Atualizar um componente setando novas configurações ou opções a ele, dizendo apenas qual o componente a ser atualizado

/**
* Faz com que o componente passado por parâmentro seja
* atualizado na tela
* @param uic componente a ser atualizado
*/
private void doPartialRefresh(UIComponent uic) {
AdfFacesContext adfctx = AdfFacesContext.getCurrentInstance();
adfctx.addPartialTarget(uic);
}

Partialtriggers
Define que um componente será reatualizado quando algum outro por alterado

af:selectonechoice label="Teste"
required="true"
binding="#{backing_teste.oneChoice}"
partialtriggers="IdComponente"
id="selectOneChoice"
/af:selectonechoice

OBS: para que essa atualização ocorra normalmente o componente que ira disparar as alteraçoes deve estar com a propriedade autoSubmit ou partialSubmit setado para true

Valores de Sessao com DWR

Buscando valores de objetos na sessão, via dwr, e jogando valores em um campo na tela diretamente do java:

import org.directwebremoting.WebContext;
import org.directwebremoting.WebContextFactory;
import org.directwebremoting.proxy.dwr.Util;

 /**
 * pega o WebContex - classe do DWR
 * objeto faz a ligacao com o servlet
 *
 * @return objeto WebContext
 */
 private WebContext getWebContext() {
    return WebContextFactory.get();  
 }

 /**
  * Pega o objeto usuário que está na sessão ativa
  *
  * @return Usuário
  */
 private OBJETO getOBJETO() {
     return (OBJETO) this.getWebContext().getSession().getAttribute("OBJETO");
 }

 /**
  * pega o objeto Útil - classe do DWR que permite
  * operacoes com os elementos HTML
  *
  * @return objeto Util
  */
  private Util getUtilThis() {
     return new Util(getWebContext().getScriptSession());
  }

 //Aqui passa um valor e um campo da tela e via dwr
 // ele seta o valor para o campo na tela
 private void setarValor(String valor,String nomeCampo){
this.getUtilThis().setValue(nomeCampo, String.valueOf(valor));
 }

E para que tudo isso funcione basta estar configurado corretamente o DWR, e para isso é só dar uma olhada no outro post sobre o assunto.

Acesso a banco Oracle, Firebird, SQL Server via Java

Um codigo simples e rapido para conectar em 3 bancos de dados:
Oracle, Firebird, SQL Server

Estou usando os seguintes drivers
Oracle: ojdbc14.jar
SQL Server: jtds-1.2.jar
Firebird: jaybird-full-2.0.1.jar

Todos esses podem ser facilmente encontrados em uma procura rapida no google (ou generico)

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class OracleRM {
  public OracleRM() {
  }

  private static final String url =
    //Oracle:
    // "jdbc:oracle:thin:@ENDERECO_DO_SEU_SERVIDOR:PORTA:BASE_DE_DADOS";
    //SQL Server 1433 é a porta padrao
    // "jdbc:jtds:sqlserver://ENDERECO_DO_SEU_SERVIDOR:1433/BASE_DE_DADOS";
    //Firebird:
    // "jdbc:firebirdsql://ENDERECO_DO_SEU_SERVIDOR/CAMINHO_BASE_DE_DADOS";

  private static final String driver =
    //Oracle:
    // "oracle.jdbc.driver.OracleDriver";
    //SQL Server
    // "net.sourceforge.jtds.jdbc.Driver";
    //Firebird:
    // "org.firebirdsql.jdbc.FBDriver";

  private static final String usuario = "usuario";
  private static final String senha = "senha";
  
  public Connection getConnection() throws SQLException {
      try {
          Class.forName(driver);
          return DriverManager.getConnection(url, usuario, senha);
      } catch (Exception e) {
          e.printStackTrace();
          return null;
      }
  }

}

Ajax com DWR

Esse é um tutorial simples, de como usar e implementar o DWR para obter funcionalidades em Ajax.

Documentaçao melhor pode ser encontrada no site: DWR

Continuando...

Primeiro é preciso baixar o dwr.jar na pagina acima, e adicionar a sua aplicaçao.

Em seguida, no seu web.xml é necessario incluir estas linhas, para configuraçao do servlet do dwr:

Após feito isso, tem que ser criado na mesma pasta do web.xml, um arquivo chamado dwr.xml, e nele será feito o mapeamento das classes chamadas via javascript.

Segue basicamente este padrao:

Na imagem:
create creator="new" javascript="Index"
O tipo de contrutor e o apelido que sera usado no javascript
param name="class" value="ajax.backing.Index"
Aqui é especificado o caminho onde se encontra a classe.

Depois de configurado esses dois arquivos, rode sua aplicaçao e acesse o caminho:
aplicaçao/dwr

Nesse caminho, será listado as classes que foram mapeadas:

Clicando em uma delas:


É entao mostrado uam breve descrição dos metodos que ela disponibiliza, e também, no topo da pagina, as tags necessarias para usar esta classe na sua pagina.

Agora falta apenas copiar essas tags e incluir na sua pagina.

Entao só é preciso usar as funcoes, e poder ser como esse exemplo simples:
Que chama :
E esta... chama a classe mapeada anteriormente:

Feito isso, esta pronto uma implementação basica do DWR.

Design Factory II - Editando dataset

Este metodo monta novos dataset para o relatório, de acordo com os parâmetros passados, aqui ele recebe parâmetros que atendiam as minhas necessidades, e que podem parecer um pouco confusos para entender.

Futuramente quando tiver tempo para melhorar o código eu o farei e atualizarei o post aqui, mas por enquanto, isso já será de grande ajuda para quem estiver com o mesmo problema que eu tinha.

Fica a cargo de cada um, implementar novas funcionalidades para este método, mas a estrutura original para incluir o novo dataset no relatório é basicamente esta.

  /**
   *  Controi o novo Data Set com a consulta
   * modificada pelo usuário
   * @param qry
   * @param designFactory
   * @param designHandle
   */
  void buildDataSet(Long codirela, String qry,
       ElementFactory designFactory,
                    ReportDesignHandle designHandle) {    
      try {
          OdaDataSetHandle dsHandle =
              designFactory.newOdaDataSet(
                  "Data Set",
                  "org.eclipse.birt.report.data.oda."+
  "jdbc.JdbcSelectDataSet");

          dsHandle.setDataSource("Data Source");
          dsHandle.setName("Data Set");
          dsHandle.setQueryText(qry);
          designHandle.getDataSets().drop(0);
          designHandle.getDataSets().add(dsHandle);
      } catch (SemanticException e) {
          e.printStackTrace();
      }            
  }

Design Factory I - Editando datasource

Como falei anteriormente, vou postar agora o método de designFactory, onde será alterado algumas particularidades do relatório.

Esse metodo recebe um IReportRunnable e o abre para que seja possivel alterar o dataSource e dataSet, mas podem ser alteradas outras propriedades, ficando para o desenvolvedor decidir sobre o que deve ser mudado.

/**
* Monta a estrutura para o relatorio, criando o data source
*e se necessario o data set
* @param design a ser alterado
*/
private void designFactory(IReportRunnable design) {
   FacesContext fc     = FacesContext.getCurrentInstance();
   ValueBinding vbUser =
      fc.getApplication().createValueBinding("#{usuario}");
   //Busca o usuario na sessao
   Usuario user = (Usuario) vbUser.getValue(fc);

   //Busca a url da base no arquivo de propriedades
   String  base = new ResourceManager().getProperties().
  getString(ResourceManager.JDBC_URL).toString();

   ReportDesignHandle report =
       (ReportDesignHandle) design.getDesignHandle();
   ElementFactory designFactory =
   report.getElementFactory();


   buildDataSource(designFactory, report,
 user.getApelpess(),user.getSenhaweb(), base);

   // Montar DataSet dinamicamente!
   // Esta parte sera melhor descrita em um post posterior
   if (ObjRel.getConsulta() != null) {
       buildDataSet(ObjRel.getRelatorio().getCodirela(),
               ObjRel.getConsulta(), designFactory, report);
   }
}

/**
* Monta o data source com o usuario da sessao e base na
* qual ira conectar
* @param designFactory
* @param designHandle
* @param usuario nome do usuario para conectar ao banco
* @param senha senha para conectar ao banco
* @param base url de onde esta a base de dados
*/
void buildDataSource(ElementFactory designFactory,
           ReportDesignHandle designHandle, String usuario,
           String senha, String base) {
   try {
       OdaDataSourceHandle dsHandle =
           designFactory.newOdaDataSource(
               "Data Source",
  "org.eclipse.birt.report.data.oda.jdbc");

       dsHandle.setProperty("odaDriverClass",
                            "org.firebirdsql.jdbc.FBDriver");
       dsHandle.setProperty("odaURL", base);
       dsHandle.setProperty("odaUser", usuario);
       dsHandle.setProperty("odaPassword", senha);
       dsHandle.setName("Data Source");
       designHandle.getDataSources().drop(0);
       designHandle.getDataSources().add(dsHandle);
   } catch (SemanticException e) {
       e.printStackTrace();
   }
}

Relatorios com o Birt

Segue abaixo um HttpServlet responsável por interpretar arquivo de design do Birt, e exibi-los.
Futuramente irei demonstrar como alterar DataSource e DataSet em tempo de execuçao.

import org.eclipse.birt.report.engine.api.EngineConstants;
import org.eclipse.birt.report.engine.api.HTMLRenderContext;
import org.eclipse.birt.report.engine.api.HTMLRenderOption;
import org.eclipse.birt.report.engine.api.IReportEngine;
import org.eclipse.birt.report.engine.api.IReportRunnable;
import org.eclipse.birt.report.engine.api.IRunAndRenderTask;
import org.eclipse.birt.report.model.api.ElementFactory;
import org.eclipse.birt.report.model.api.OdaDataSetHandle;
import org.eclipse.birt.report.model.api.OdaDataSourceHandle;
import org.eclipse.birt.report.model.api.ReportDesignHandle;
import org.eclipse.birt.report.model.api.activity.SemanticException;


import java.io.IOException;
import java.io.PrintWriter;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import java.util.HashMap;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.faces.context.FacesContext;
import javax.faces.el.ValueBinding;

import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;


/**
* Class description
*
*/
public class BuildRelatorio extends HttpServlet {

/** Field description */
private static final long serialVersionUID = 1L;
protected static Logger   logger           =
    Logger.getLogger("org.eclipse.birt");

/**
 *
 */
private Connection currentConnection = null;

/**
 * Constructor of the object.
 */
private IReportEngine birtReportEngine = null;

/** Field description */
private ObjRelatorio ObjRel;


/**
 * Constructs ...
 *
 */
public BuildRelatorio() {
    super();
}

/**
 * Destruction of the servlet.
 *
 */
public void destroy() {
    super.destroy();
    BirtEngine.destroyBirtEngine();
}

/**
 * The doGet method of the servlet.
 *
 * @param req
 * @param resp
 * @throws ServletException
 * @throws IOException
 */
public void doGet(HttpServletRequest req,
    HttpServletResponse resp)
        throws ServletException, IOException {

    // get report name and launch the engine
    resp.setContentType("text/html");

    // resp.setContentType( "application/pdf" );
    ServletContext sc = req.getSession().
    getServletContext();

    this.birtReportEngine = BirtEngine.
    getBirtEngine(sc);

    // setup image directory
    HTMLRenderContext renderContext =
    new HTMLRenderContext();
    String  pastaImagens  = "pastaImagens";

    renderContext.setBaseImageURL(pastaImagens);
    renderContext.setImageDirectory(pastaImagens);
    logger.log(Level.FINE, pastaImagens);

    HashMap contextMap =
        new HashMap();

    contextMap.put(EngineConstants.
 APPCONTEXT_HTML_RENDER_CONTEXT, renderContext);

    IReportRunnable design;

    try {

        // Open report design
        String reportName = "N";

        design = birtReportEngine.
   openReportDesign(reportName);

 //Esta parte sera descrita em um post futuro        
 //designFactory(design);

        // create task to run and render report
        IRunAndRenderTask task =
            birtReportEngine.createRunAndRenderTask(
      design);

        task.setAppContext(contextMap);

        // set output options
        HTMLRenderOption options = new HTMLRenderOption();

        options.setOutputFormat(HTMLRenderOption.
     OUTPUT_FORMAT_HTML);

        // options.setOutputFormat(HTMLRenderOption.
     OUTPUT_FORMAT_PDF);
        options.setOutputStream(resp.getOutputStream());
        task.setRenderOption(options);

        // run report
        task.run();
        task.close();
    } catch (Exception e) {
        e.printStackTrace();
        throw new ServletException(e);
    }
}

/**
 * The doPost method of the servlet.     *
 *
 * @param request
 * @param response
 * @throws ServletException
 * @throws IOException
 */
    public void doPost(HttpServletRequest request,
                     HttpServletResponse response)
          throws ServletException, IOException {
      response.setContentType("text/html");

      PrintWriter out = response.getWriter();

      out.println("CODIGOS HTML");
    
  }
/**
 * Initialization of the servlet.
 *
 *
 * @throws ServletException if an error occure
 */
public void init() throws ServletException {
    BirtEngine.initBirtConfig();
}
}

E - mail em Java

Não seria esse o objetivo desse blog, mas, como os atuais acontecimentos mudaram minha perspectiva sobre diversos assuntos, decidi contribuir repassando minhas dificuldades e soluções encontradas, para que se alguém porventura compartilhe das mesmas, consiga melhores respostas.

Essa é uma classe para enviar email, bem simples, porem pode ser útil.

import java.util.Properties;

import javax.faces.application.FacesMessage;

import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

/**
* @author Mauricio Couto Pelissari
*/
public class EmailSender {
/**
* Envia email  atraves do  servidor definido
*/
public   EmailSender () {
}

// ~--- methods ----------------------

/**
* @param emailDest -
*            Email para onde sera enviado (obrigatorio)
* @param emailCopia -
*            Email para enviar uma copia da msg
    * @param emailCopiaOculta -
    *            Email para enviar copia oculta
* @param emailEnv -
*            Email de onde foi enviado (obrigatorio)
* @param titulo -
*            Titulo do email
* @param mensagem -
*            Mensagem do email
*/
public void send(String servidor, String emailDest,
               String emailCopia, String emailCopiaOculta,
               String emailEnv, String titulo,
               String mensagem) {
  Properties p = new Properties();
  if (servidor == null)  {
      servidor = "Servidor de email padrao";         
  } 

  p.put("mail.transport.protocol", "smtp");
  p.put("mail.smtp.host",servidor);
  p.put("mail.smtp.port", "25");
  // p.put("mail.smtp.user", usuario);
  // p.put("mail.password", "xxx");
  // p.put("mail.smtp.startssl.enable","true");
  // p.put("mail.smtp.starttls.enable","true");
  // p.put("mail.smtp.auth", "true");
  p.put("mail.smtp.debug", "true");
  p.put("mail.smtp.socketFactory.port", "25");
  // p.put("mail.smtp.socketFactory.class",
  // "javax.net.ssl.SSLSocketFactory");
  p.put("mail.smtp.socketFactory.fallback", "false");

  Session session = Session.getInstance(p, null);

  session.setDebug(true);

  MimeMessage msg = new MimeMessage(session);

  try {

      // "de" e "para"!!     
      msg.setFrom(new InternetAddress(emailEnv.toLowerCase()));
      msg.setRecipient(Message.RecipientType.TO,
                 new InternetAddress(emailDest.toLowerCase()));
      if (emailCopia != null) {
          msg.setRecipient(Message.RecipientType.CC,
                new InternetAddress(emailCopia.toLowerCase()));
      }
      if (emailCopiaOculta != null) {
        msg.setRecipient(Message.RecipientType.BCC,
          new InternetAddress(emailCopiaOculta.toLowerCase()));
      }

      // assunto da mensagem
      if (titulo.length() > 0) {
          msg.setSubject(titulo);
      } else {
          titulo = "Sem Titulo!";
      }


      // corpo da msg
      if (mensagem.length() > 0) {
          msg.setText(mensagem);
      } else {
          mensagem = "Sem mensagem!";
      }

      // Enviando mensagem (tentando)
      Transport.send(msg);
  } catch (AddressException e) {
      e.printStackTrace();
      //Tratamento do erro
  } catch (MessagingException e) {
      e.printStackTrace();
      //Tratamento do erro
  }
}
}