Sunteți pe pagina 1din 23

Sumário

1 – Customizando o Fusion ..................................................................................................... 3


1.1 – Conhecendo os principais objetos do Fusion ............................................................ 3
1.1.1 - NeoObject ............................................................................................................ 3
1.1.2 - InstantiableEntityInfo .......................................................................................... 3
1.1.3 - EntityWrapper .................................................................................................... 4
1.1.4 - PersistEngine....................................................................................................... 5
1.1.3.1 - Persistindo os dados em um formulário.......................................................... 5
1.1.3.2 - Recuperando os dados de um formulário ....................................................... 6
1.1.2 - NeoUser ............................................................................................................... 7
2.2 – Desenvolvendo adapters para Workflows................................................................. 8
2.2.1 – Incluindo adapters no modelo do processo ....................................................... 8
2.2.2 – Exemplo de adapters de Workflow – Persistindo dados em uma tabela externa
............................................................................................................................................. 10
3- Utilizando o Agendador de Tarefas .................................................................................. 11
3.2 – Exemplo de Adapter para o Agendador de Tarefas – Importador Simplificado...... 12
5 - Bloco Try...Catch .............................................................................................................. 13
6 - Geração de Log ................................................................................................................ 13
7 – Atividade Envio - Customizando Modelo de E-mail ....................................................... 14
7.1 – Exemplo de Modelagem Fluxo com Atividade de Envio de E-mail.......................... 16
7.2 – Exemplo de Modelo de E-mail ................................................................................. 17
8 – Ferramentas e Utilitários ................................................................................................ 20
8.1 – Visualizando a estrutura de dados do formulário com dumpEFormTree ............... 20
8.2 – Visualizando os dados de um Objeto com dumpNeoObject ................................... 21
8.3 – Habilitando log seletivo ........................................................................................... 22
8.4 – Consultando a base com SQL ................................................................................... 22
8.5 – Visualizando os usuários online com activeUsers ................................................... 23
1 – Customizando o Fusion

O Fusion ECM Suite foi desenvolvido pensando-se em escalabilidade. Como


consequência cada contexto do Fusion está preparado para receber novas funcionalidades,
portanto tudo que o produto padrão não contemple, pode ser desenvolvido como
customização através do uso de Adapters Java. Para desenvolver adapters é necessário um
ambiente de desenvolvimento com o Fusion instalado. O ambiente utilizado na Neomind é o
Eclipse IDE. Também é essencial o conhecimento da linguagem de programação Java,
especificamente no contexto de desenvolvimento de aplicações WEB.

1.1 – Conhecendo os principais objetos do Fusion

1.1.1 - NeoObject

NeoObject é o objeto mais genérico no Fusion, todos os outros objetos extendem ele.
Para obter a Id de um Objeto utilize o método getNeoId(). Também as questões de segurança
do fusion estão associadas a este objeto, vários métodos de validações de segurança são
invocados a partir do NeoObject.

1.1.2 - InstantiableEntityInfo

Entidades são classes que mapeiam e representam uma tabela no banco de dados.
Para obter a instância de uma entidade, um objeto do tipo InstantiableEntityInfo deve ser
criado para representá-la. Para criarmos uma instância de uma entidade usamos o método
createNewEntityInstance(String entityName) da classe AdapterUtils. O parâmetro do
método é um objeto do tipo String que será o nome da entidade (formulário ou tabela) criado
no Fusion. Lembrando que o formulário pode ser dinâmico ou externo. Este objeto é
posteriormente passado como argumento dos métodos getObject()e getObjects() da classe
PersitEngine, que realizam a busca na tabela(formulário).

O código abaixo exemplifica o uso da entidade para mapear a tabela(Formulário) “Produto” .


O formulário “Produto” pode tanto ser um formulário dinâmico criado no banco do Fusion
quanto uma tabela externa pertencente a um sistema legado. Se “Produto” for um formulário
externo, a Fonte de Dados primeiramente deve ser criada no Fusion, e posteriormente o
formulário externo, sendo que o Nome do formulário será o argumento passado para o
método createNewEntityInstance;

// NeoObject é inicializado com uma instâcia que da entidade Produto

NeoObject produtoFusion = AdapterUtils.createNewEntityInstance("Produto");


1.1.3 - EntityWrapper

Wrappers são classes com o papel de encapsular as Entidades, abstraindo sua


interface simplificando as operações de leitura e escrita dos dados no banco. No Fusion o
EntityWrapper é a classe que encapsula a entidade.

A tabela abaixo descreve os métodos mais usados do EntityWrapper:

Método Descrição
findField Retorna um Wrapper para manipulação do
campo se o campo existir, senão retorna null
findValue Retorna um objeto com o valor do campo
findValues Retorna uma coleção de objetos
findGenericValue Retorna um objeto genérico com o valor do
campo

No código abaixo primeiro criamos uma instância da entidade “Produto” e atribuímos ela a um
NeoObject que representará a tabela no banco, em seguida embrulhamos ela com um
wrapper instanciando a classe EntityWrapper passando para o construtor desta o argumento
NeoObject contendo a entidade, encapsulando assim sua complexidade, agora todas
operações de leitura e escrita no banco serão realizados através do objeto wrapper. Este
método simplifica as operações de banco escondendo os detalhes de relacionamentos entre
tabelas que serão controlados pelo Hibernate.

// NeoObject é inicializado com uma instâcia da entidade Produto

NeoObject produtoFusion = AdapterUtils.createNewEntityInstance("Produto");

EntityWrapper wrapperProdutoFusion = new EntityWrapper(produtoFusion);


1.1.4 - PersistEngine

A classe PersistEngine, existente no núcleo do Fusion, centraliza toda a comunicação


com o banco de dados. É nela que os principais métodos de obtenção e atribuição de valores
existentes no banco são implementados.
A tabela abaixo descreve alguns dos métodos mais usados do PersistEngine:

Método Descrição
getConnection Retorna um objeto de conexão para a fonte
de dados. Recebe uma String com o nome da
fonte de dados como parâmetro.
persit Persiste os dados no banco, recebe como
parâmetro um objeto que referencia a
entidade.
getObject Retorna a instância de um objeto. Recebe
como parâmetro um objeto classe.
getObjects Retorna uma lista ou coleção de instâncias de
objetos. Além do objeto representando a
entidade os métodos também podem ter
como parâmetro filtros, assim o resultado
retornado será uma instância específica ou
um subconjunto de instâncias de acordo com
os critérios definidos pelos filtros.

1.1.3.1 - Persistindo os dados em um formulário

No exemplo abaixo, foi criado um formulário dinâmico com o nome de “Produto”


com dois campos cujos nomes são “código” e “descricao”. Depois incluímos um registro no
formulário utilizando o wrapper e por último persistimos o registro usando o método persit da
classe PesistEngine.

//instancia objeto no fusion e seta valores


NeoObject produtoFusion = AdapterUtils.createNewEntityInstance("Produto");

// cria wrapper para abstrair a Entidade que representa “eduProduto”


EntityWrapper wrapperProdutoFusion = new EntityWrapper(produtoFusion);

// Atribui valores a variáveis locais


String numeroProduto = “AFR – 233”;
String descricao = “Montain Bike”;

//Usa o wrapper para atribuir os valores aos campos


wrapperProdutoFusion.findField("codigo").setValue(numeroProduto);
wrapperProdutoFusion.findField("descricao").setValue(descricao);

//persistindo os dados no banco


PersistEngine.persist(produtoFusion);
Normalmente os passos para Ler/Escrever em formulários são :

1- Crie uma entidade para representar o formulário (tabela)

//instancia objeto no fusion e seta valores


NeoObject produtoFusion = AdapterUtils.createNewEntityInstance("Produto");

2- Crie um wrapper para encapsular a entidade

// cria wrapper para abstrair a Entidade que representa “eduProduto”


EntityWrapper wrapperProdutoFusion = new EntityWrapper(produtoFusion);

3- Use o wrapper para escrever/ler/alterar os dados no banco

// Atribui valores a variáveis locais


String numeroProduto = “AFR – 233”;
String descricao = “Montain Bike”;

//Usa o wrapper para atribuir os valores aos campos


wrapperProdutoFusion.findField("codigo").setValue(numeroProduto);
wrapperProdutoFusion.findField("descricao").setValue(descricao);

4- Use o mecanismo de persistência do hibernate para persistir/remover os dados

//persistindo os dados no banco


PersistEngine.persist(produtoFusion);

1.1.3.2 - Recuperando os dados de um formulário

O código abaixo exemplifica a recuperação dos registros em um formulário. Através do


método getObjects os registros encontrados no formulário “Produto” são carregados para
dentro de uma lista de objetos tipo NeoObject. Em seguida usamos um looping “for” para
percorrer a lista usando um iterador percorremos cada registro até o final da lista, note que
utilizamos um wrapper para para realizar a operação sobre a entidade (tabela), o método
findField retorna o campo do objeto e o método getValue traz o valor do campo. No final
usamos a classe System para mostrar os valores no console a cada iteração na lista.

List<NeoObject> listaProduto = (List<NeoObject>)


PersistEngine.getObjects(AdapterUtils.getEntityClass("Produtos"));

for(NeoObject produto : listaProduto)


{
//dados eform externo
EntityWrapper wrapperProdutos = new EntityWrapper(produto);
String codigo = (String) wrapperProdutos.findField("codigo").getValue();
String descricao = (String) wrapperProdutos.findField("descricao").getValue();

//mostra valores dos campos

System.out.println(codigo+"\n");
System.out.println(descricao);

//remove objeto
PersistEngine.remove(produtoFusion);

1.1.2 - NeoUser

A classe NeoUser representa a abstração de um usuário do sistema. Ela é utilizada


quando uma ação específica a um usuário ou grupo de usuários deve ser realizada. Através
dela, uma referência ao usuário atual do sistema é obtida, retornando um objeto, que pode
ser utilizado em diversas ocasiões, como na verificação do papel do usuário.

Para obter o usuário atual logado, utilize o código apresentado abaixo.

// A variável ‘user’ recebe o objeto que representa o usuário.

NeoUser user = PortalUtil.getCurrentUser();

Para verificar o papel em que o usuário está inserido, é necessário criar o


objeto que mantém a referência do usuário, conforme o código acima. O exemplo abaixo
demonstra como verificar se o usuário atual está no papel Estagiário.

boolean isEstagiario = user.isInRole(SecurityManager.getInstance().getRole("Estagiário"));

Através da variável user, que representa o usuário logado, utiliza-se o método


isInRole(). Este método, por fim, recebe um parâmetro contendo o nome do papel, neste caso,
“Estagiário”. Se o usuário estiver neste papel, a variável isEstagiario receberá true, caso
contrário, false.
2.2 – Desenvolvendo adapters para Workflows

Na fase de construção do Workflow algumas funcionalidades necessárias para


automatizar o processo tais como integrações, validações, elementos de interface, etc. podem
demandar o desenvolvimento de adapters de Workflow. Estes possuem características
específicas dentro do contexto de Workflow, e devem implementar a classe AdapterInterface
que possui dois métodos obrigatórios o método start() e o back() . Normalmente o código
para os adapters de workflow é desenvolvido dentro destes dois métodos.

2.2.1 – Incluindo adapters no modelo do processo

Para incluirmos um adapter de workflow no processo, precisamos inclui-lo na


modelagem. O adapter é uma atividade do tipo Script, para alterarmos a atividade para o tipo
Script, clique na atividade, no ícone de atalho para o tipo de atividade escolha Script.

Depois de alterado para o tipo Script a caixa de atividade mudará de cor, e também o
Painel de Propriedades terá suas propriedades alteradas para o contexto de Script. No painel
de propriedades preencha o campo “Descrição”, e no campo “Tipo de Script” deixe o valor
padrão que é “adapter”, na propriedade “Classe Java” informe o namespace da classe Java
desenvolvida. Muito cuidado com o namespace pois qualquer erro impedirá que o Adapter
funcione.
A maneira mais segura de copiar o namespace no Eclipse é posicionar o cursor sobre o nome
da classe e clicar com o botão direito, selecionar o item “Copy Qualified Name”, o Eclipse
copiará para a área de transferência o namespace da classe. Cole na propriedade “Classe Java”
no Painel de Propriedades. Assim a possibilidade de erros de digitação será anulada.
2.2.2 – Exemplo de adapters de Workflow – Persistindo dados em uma tabela
externa

public class CadastraPgtoERP implements AdapterInterface


{

@Override
public void start(Task origin, EntityWrapper processEntity,
Activity activity)
{
// TODO Auto-generated method stub

StringBuffer sql = new StringBuffer();


sql.append("INSERT INTO produto");
sql.append(" (ProductID, Name, ProductNumber, Color , StandardCost , ListPrice, Size,
Weight, SellStartDate,rowguide, ModifiedDate)");
sql.append(" VALUES( ?, ?, ?, ?, ?, ?, ?, ?, ?, NEWID(),
GETDATE() )");

Long productId = null;


String name =null;
String productNumber = null;
String color = null;
BigDecimal standadCost = null;
BigDecimal listPrice = null;
String size = "45";
BigDecimal weight = new BigDecimal(4433.78);
GregorianCalendar sellStartDate = null;
productId = (Long) processEntity.findValue("codigo");
name = (String) processEntity.findValue("nome");
productNumber = (String) processEntity.findValue("productNumber");
color = (String) processEntity.findValue("color");
standadCost = (BigDecimal) processEntity.findValue("cost");
listPrice = (BigDecimal) processEntity.findValue("listPrice");
sellStartDate =(GregorianCalendar) processEntity.findValue("sellStartDate");
Date x = new Date(sellStartDate.getTimeInMillis());//converte gregorian para Date
Connection connection = PersistEngine.getConnection("Neo Produto");
PreparedStatement st = null;
try
{
connection.setAutoCommit(false);
st = connection.prepareStatement(sql.toString());
st.setLong(1, productId);
st.setString(2, name);
st.setString(3, productNumber);
st.setString(4, color);
st.setBigDecimal(5,standadCost);
st.setBigDecimal(6, listPrice);
st.setString(7, size);
st.setBigDecimal(8, weight);
st.setDate(9, x);
st.executeUpdate();
connection.commit();
}
catch (Exception e)
{
e.printStackTrace();
throw new WorkflowException("Erro ao Salvar os dados "+e.getMessage());
}
finally
{
try
{
st.close();
connection.close();
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
}
3- Utilizando o Agendador de Tarefas

O Agendador de Tarefas permite a execução de tarefas automaticamente de acordo


com parâmetros temporais configurados previamente. Deste modo podemos gerar tarefas
para sincronizar bancos, iniciar Workflows automaticamente, limpar logs, etc. As tarefas a
serem executadas devem estar contidas em um adapter java, e devem implementar a
interface CustomJobAdapter . O código a ser executado estará dentro do método execute.

Para agendar uma tarefa clique em Novo, dê um nome e uma descrição para a tarefa,
e defina o campo Habilitado para Sim. No campo Adapter informe o namespace da classe que
será executada. Configure o Gatilho que executará a tarefa no painel Gatilho clique em Novo
preencha os campos solicitados para repetir a execução agendada.
3.2 – Exemplo de Adapter para o Agendador de Tarefas – Importador Simplificado

O código abaixo exemplifica a estrutura de um adapter para o agendador de tarefas.


Neste exemplo os dados de uma tabela externa são importados para um formulário dinâmico
do Fusion.

public class ExemploAgendadorImportaDados implements CustomJobAdapter


{

@Override
public void execute(CustomJobContext ctx)
{
// TODO Auto-generated method stub

List<NeoObject> listaProduto = (List<NeoObject>)


PersistEngine.getObjects(AdapterUtils.getEntityClass("AdventureProdutos"));

for(NeoObject produto : listaProduto)


{
//dados eform externo
EntityWrapper wrapperProdutos = new EntityWrapper(produto);
String descricao = (String) wrapperProdutos.findField("name").getValue();
String numeroProduto = (String) wrapperProdutos.findField("productnumber").getValue();

//instancia objeto no fusion e seta valores


NeoObject produtoFusion = AdapterUtils.createNewEntityInstance("Produto");
EntityWrapper wrapperProdutoFusion = new EntityWrapper(produtoFusion);

wrapperProdutoFusion.findField("codigo").setValue(numeroProduto);
wrapperProdutoFusion.findField("descricao").setValue(descricao);

//mostra valores dos campos a serem importados no console

System.out.println(numeroProduto+"\n");
System.out.println(descricao);

//persistindo objeto
PersistEngine.persist(produtoFusion);

}
5 - Bloco Try...Catch

Para manter um melhor controle da execução do código e otimizar o tratamento de


erros, é importante que o código dos adapters seja inserido entre um ou mais blocos
try...catch. A função deste bloco é isolar e tratar qualquer erro que ocorra no código,
impedindo que este erro interrompa a execução de outra parte do código.
O exemplo abaixo mostra um código simples de adapter. Primeiro, um campo é lido no
workflow. Se o valor dele for diferente de “Processo Judicial”, o valor é alterado. Todo o código
está envolvido no bloco try...catch e, caso um erro ocorra, uma mensagem é apresentada.

public void start(Task origin, EntityWrapper wrapper, Activity activity)


{
try // início do bloco try
{
String tipoProcesso = wrapper.findValue(“TipoProcesso”);
if (!tipoProcesso.equals(“Processo Judicial”))
{
wrapper.findField(“TipoProcesso”).setValue(“Processo Judicial”);
}
}catch (Exception e) // fim do bloco try
{
// Mensagem apresentada quando o erro ocorre
System.out.println(“Erro ao executar o código do adapter!”)
}
}

6 - Geração de Log

A geração de logs é muito importante para realizar a manutenção do sistema. Quando


um evento inesperado ocorre, é necessário que uma informação referente a ele seja gerada.
Isto é feito através da classe LogFactory, que fornece os métodos necessários para se gerar o
log do evento.
O trecho de código abaixo reproduz a situação onde o valor de um campo denominado
Versao é lido do e-form de um processo, através de um adapter, porém o nome do campo é
passado de forma errada (Versaao), gerando um erro no Fusion que será gravado no log.

//Criação do objeto log, utilizando o nome da classe atual


private static final Log log = LogFactory.getLog(NomeDaClasse.class);

public void start(Task origin, EntityWrapper wrapper, Activity activity)


{
try
{
String versao = wrapper.findField(“Versaao”).getValue();
}catch (Exception e)
{
log.error(“Erro ao ler o campo Versao no e-form!”,e);
}
}
7 – Atividade Envio - Customizando Modelo de E-mail

A comunicação é uma das áreas críticas dentro das organizações, mecanismos de


notificação são extremamente úteis para que as metas sejam atingidas. No Fusion o envio de
notificação por e-mail para as Atividades de Usuário é automático.

No entanto, quando se trata de uma Atividade de Envio é necessário configurar o


envio. Ao selecionar a Atividade de Envio na caixa de atividades ela mudará de cor e as
propriedades de configuração serão alteradas para o Tipo Envio.

Neste tipo de atividade a continuidade do fluxo não depende da execução da atividade


para avançar. É utilizada como informativo para pessoas que não executam nenhuma tarefa no
processo, mas precisam ser notificadas quando algum evento ou atividade acontece e também
para notificar pessoas externas a organização, que não utilizam o Fusion.

No Painel de Propriedades o campo Enviar para participante: Indica se o e-mail vai ser
enviado para o participante da Raia. Se “Sim” o e-mail de notificação será enviado para os
participantes da raia (usuário/papel/grupo) . Se o valor de Enviar para Participante for “Não” o
campo Enviar para deve ser preenchido com um campo do tipo Usuário/Papel/Grupo, ou tipo
Texto quando os destinatários não forem usuários do Fusion. Neste caso os e-mails dos
destinatários devem ser separados por ponto e vírgula (;) e podem ser preenchidos em tempo
de execução ou incluídos na Propriedade Valor Padrão do campo tipo Texto. Caso o e-mail
deva ser enviado tanto para usuários do Fusion participantes da Raia e para pessoas que não
utilizam o Fusion (parceiros de negócios). O valor do Campo Enviar para participante deve ser
“sim” e o valor do campo Enviar para também deve ser preenchido.
Para que esta atividade funcione é necessário informar o Modelo do e-mail que será
utilizado. Para isto, se faz necessário criar uma servlet java que renderizará o e-mail
formatado. Através deste modelo poderemos informar no corpo do e-mail informações
específicas da instância do processo. Por exemplo, o solicitante, data da solicitação ou
qualquer campo que faça parte do formulário do processo, inclusive dados de formulários
externos que sejam filhos do formulário do processo.

O nome do modelo deve ser informado juntamente com o caminho em que se


encontra no servidor na pasta de instalação do Fusion. No caso de modelo de e-mail o arquivo
modelo deverá ser salvo na pasta mail. As imagens usadas no corpo do e-mail devem ser
salvas na pasta imagens na pasta de instalação do Fusion. No exemplo abaixo foi informado o
seguinte valor no campo Modelo do E-mail: /mail/enviaEmailExemplo.jsp . Mais abaixo
mostramos o código do arquivo enviaEmailExemplo.jsp.
7.1 – Exemplo de Modelagem Fluxo com Atividade de Envio de E-mail

No fluxo abaixo temos um exemplo simples do uso da Atividade de Envio. O fluxo


inicia na tarefa “Solicitar Inclusão Novo Produto” solicitando a inclusão, em seguida é usado o
componente de Decisão Paralela para dividir o fluxo notificando os participantes da Raia
Notificados e ao mesmo tempo segue para aprovação. Na tarefa “Aprovar Inclusão” o gestor
da área aprovará ou não a inclusão do novo produto, caso ele aprove, o fluxo seguirá para a
tarefa “Incluir Produto” em seguida notificando os interessados. Caso o gestor não aprove, o
fluxo seguirá para a atividade de notificação. Antes do final mais um componente de Decisão
paralela é utilizado, neste caso para unir os dois fluxos novamente.

Na atividade “Notifica Solicitação” a propriedade Enviar para participantes está com o


valor “Sim”, e neste caso a notificação será apenas para os usuários participantes da Raia

Na atividade “Notifica Status Final” o objetivo é notificar os participantes da Raia bem


como, pessoas externas a organização, portando o campo Enviar para também está
configurado, neste caso com um campo do tipo Texto cujo Valor Padrão é uma lista de e-mail
separado por ponto e virgula (;).

7.2 – Exemplo de Modelo de E-mail


O código abaixo exemplifica a criação do modelo de e-mail:

<%@page import="com.neomind.fusion.portal.PortalUtil"%>
<%@page import="com.neomind.fusion.common.NeoObject"%>
<%@page import="com.neomind.fusion.persist.PersistEngine"%>
<%@ taglib uri="/WEB-INF/mail.tld" prefix="mail"%>
<%@ taglib uri="/WEB-INF/workflow.tld" prefix="wf"%>
<%@ taglib uri="/WEB-INF/portal.tld" prefix="portal"%>
<%@page import="java.util.*"%>
<%@page import="java.sql.Time"%>
<%@page import="com.neomind.util.NeoUtils"%>
<%@page import="com.neomind.fusion.entity.EntityWrapper"%>
<%@page import="com.neomind.fusion.workflow.Activity"%>
<%@page import="com.neomind.fusion.workflow.Task"%>
<%@page import="com.neomind.util.NeoCalendarUtils"%>
<%
NeoObject obj = (NeoObject)request.getAttribute("Entity");
EntityWrapper wrapper = new EntityWrapper(obj);

String processo = (String) wrapper.findValue("wfprocess.model.name");//NOME DO PROCESSO


String codigo = (String)wrapper.findValue("wfprocess.code"); //CODIGO PROCESSO
String codigoProduto = NeoUtils.safeOutputString(wrapper.findValue("codigo"));//CODIGO PRODUTO
String descricao = NeoUtils.safeOutputString(wrapper.findValue("descricao"));// DESCRIÇÃO
String observacao = NeoUtils.safeOutputString(wrapper.findValue("observacao"));// OBSERVÇÃO
GregorianCalendar dataSol = (GregorianCalendar) wrapper.findValue("dataSolicitacao");// PEGA A
DATA NO FORMATO JAVA CALENDAR
String dataSolicitacaoTexto = NeoCalendarUtils.fullDateToString(dataSol);//CONVERTE DATA PARA
STRING
String title= "Solicitação de Novo Produto" + " - " + codigo;
%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title></title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<portal:baseURL url="getURLPath" />
<base href="<%= PortalUtil.getBaseURL() %>" />
</head>

<body bgcolor="#FFF1D2">
<p><mail:title title='<%=title %>' /></p>
<mail:img src="/imagens/cabecalho.jpg" width="768" height="124" />
<h3><u><%=codigo %> - <%=processo %></u></h3>
<p> <strong>Codigo Produto</strong> <%=codigoProduto%> </p>
<p> <strong>Descri&ccedil;&atilde;o do Produto :</strong> <%=descricao%></p>
<p> <strong>Observa&ccedil;&atilde;o:</strong> <%=observacao%> </p>
<p><strong>Data Solicita&ccedil;&atilde;o :</strong> <%=dataSolicitacaoTexto%></p>

<mail:img src="/imagens/rodape.jpg" width="768" height="145" />


</body>
</html>
Normalmente para criarmos um template de e-mail usamos os passos a seguir:

1 – Importamos as classes necessárias

<%@page import="com.neomind.fusion.portal.PortalUtil"%>
<%@page import="com.neomind.fusion.common.NeoObject"%>
<%@page import="com.neomind.fusion.persist.PersistEngine"%>
<%@ taglib uri="/WEB-INF/mail.tld" prefix="mail"%>
<%@ taglib uri="/WEB-INF/workflow.tld" prefix="wf"%>
<%@ taglib uri="/WEB-INF/portal.tld" prefix="portal"%>
<%@page import="java.util.*"%>
<%@page import="java.sql.Time"%>
<%@page import="com.neomind.util.NeoUtils"%>
<%@page import="com.neomind.fusion.entity.EntityWrapper"%>
<%@page import="com.neomind.fusion.workflow.Activity"%>
<%@page import="com.neomind.fusion.workflow.Task"%>
<%@page import="com.neomind.util.NeoCalendarUtils"%>

2- Usamos o método getAttribute do Objeto Request para pegarmos os dados vindos do


processo, assim teremos acesso aos dados preenchidos na atividade do processo através do
argumento “Entity” que representa o formulário principal do processo.

NeoObject obj = (NeoObject)request.getAttribute("Entity");

3-Criamos um objeto wrapper para encapsular a entidade.

EntityWrapper wrapper = new EntityWrapper(obj);

5- Atribuímos o valor dos campos provenientes do processo a variáveis locais realizando


conversões de tipo quando necessário. Os valores passados para o método findValue
do objeto wrapper são os nomes dos campos do formulário do processo.

String processo = (String) wrapper.findValue("wfprocess.model.name");//NOME DO PROCESSO


String codigo = (String)wrapper.findValue("wfprocess.code"); //CODIGO PROCESSO
String codigoProduto = NeoUtils.safeOutputString(wrapper.findValue("codigo"));//CODIGO PRODUTO
String descricao = NeoUtils.safeOutputString(wrapper.findValue("descricao"));// DESCRIÇÃO
String observacao = NeoUtils.safeOutputString(wrapper.findValue("observacao"));// OBSERVÇÃO
GregorianCalendar dataSol = (GregorianCalendar) wrapper.findValue("dataSolicitacao");// PEGA A
DATA NO FORMATO JAVA CALENDAR
String dataSolicitacaoTexto = NeoCalendarUtils.fullDateToString(dataSol);//CONVERTE PARA STRING
String title= "Solicitação de Novo Produto" + " - " + codigo;
6- Formatamos o código HTML que será gerado pela Servlet, incluímos as variáveis locais
dentro das tags jsp <% %> inseridas no código HTML para renderizar os valores do
campos do processo no corpo do e-mail.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"


"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title></title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<portal:baseURL url="getURLPath" />
<base href="<%= PortalUtil.getBaseURL() %>" />
</head>

<body bgcolor="#FFF1D2">
<p><mail:title title='<%=title %>' /></p>
<mail:img src="/imagens/cabecalho.jpg" width="768" height="124" />
<h3><u><%=codigo %> - <%=processo %></u></h3>
<p> <strong>Codigo Produto</strong> <%=codigoProduto%> </p>
<p> <strong>Descri&ccedil;&atilde;o do Produto :</strong> <%=descricao%></p>
<p> <strong>Observa&ccedil;&atilde;o:</strong> <%=observacao%> </p>
<p><strong>Data Solicita&ccedil;&atilde;o :</strong> <%=dataSolicitacaoTexto%></p>

<mail:img src="/imagens/rodape.jpg" width="768" height="145" />


</body>
</html>

A imagem abaixo ilustra como ficaria o e-mail padrão de acordo como o código acima:
8 – Ferramentas e Utilitários

O Fusion traz um conjunto de ferramentas administrativas em forma de servlets que é


extremamente útil para utilização avançada do ambiente. Estas ferramentas facilitam muito o
processo de construção de workflows e customizações do sistema. Vamos ver as principais
ferramentas e sua utilização prática.

8.1 – Visualizando a estrutura de dados do formulário com dumpEFormTree

Este servlet mostra a estrutura do formulário no formato de árvore, facilitando a


visualização de todos os campos e sua estrutura. Para utilizarmos o dumpEFormTree
precisamos do perfil administrador, só este possui acesso as ferramentas de administração.
Para carregarmos este servlet basta informarmos no Navegador a URL padrão das
ferramentas administrativas seguida do nome da servlet e por último o nome do formulário.
Conforme o exemplo abaixo:

http://localhost:8080/fusion/adm/dumpEFormTree.jsp?id=sacPrincipal

Importante: neste servidor o Fusion está rodando na porta 8080 como localhost,
portanto substitua a parte http://localhost:8080 pela correspondente em seu
ambiente. SacPrincipal é o nome do formulário
Para navegar nesta estrutura clique nos campos, se forem do tipo formulário expandirão e
mostrarão os campos do mesmo.
8.2 – Visualizando os dados de um Objeto com dumpNeoObject

Com este servlet é possível visualizar os dados estruturados de um objeto. Para


carregarmos este servlet basta informarmos no Navegador a URL padrão das ferramentas
administrativas seguida da id do Objeto. Como todos objetos do Fusion possuem uma NeoId,
por exemplo, no item anterior utilizamos o dumpEFormTree para vermos a estrutura de dados
do formulário, notem o campo dadosCliente, o número que aparece é o NeoId deste objeto
veja imagem.

Agora chamamos a servlet passando este número veja abaixo:

http://localhost:8080/fusion/adm/dumpNeoObject.jsp?id=37014
8.3 – Habilitando log seletivo

Com o log seletivo podemos habilitar o log de acordo com um contexto específico,
facilitando a depuração erros no código.

Chame a URL abaixo para carregar o log seletivo:

http://localhost:8080/fusion/adm/log.jsp

Selecione nas opções quais logs específicos desejar.

8.4 – Consultando a base com SQL

O servlet SQL permite utilizarmos a linguagem SQL diretamente no banco do Fusion ou em


fontes de dados cadastradas no Fusion.

Chame a URL abaixo para carregar o servlet de SQL:

http://localhost:8080/fusion/adm/sql.jsp
Note que os formulários dinâmicos tornam-se tabelas com o prefixo “D_” e formulários
externos com o prefixo “EXT_”.
8.5 – Visualizando os usuários online com activeUsers

O servlet activeUsers lista todos os usuários do sistema que estão online no momento.
Permitindo o monitoramento do sistema.

Chame a URL abaixo para carregar o servlet activeUsers:

http://localhost:8080/fusion/adm/activeUsers.jsp

S-ar putea să vă placă și