Guia de Referência para

Customização

Workflow
Copyright © 2009 TOTVS S.A. Todos os direitos reservados.
Nenhuma parte deste documento pode ser copiada, reproduzida, traduzida ou transmitida por
qualquer meio eletrônico ou mecânico, na sua totalidade ou em parte, sem a prévia autorização
escrita da TOTVS S.A., que reserva-se o direito de efetuar alterações sem aviso prévio. A TOTVS
S.A não assume nenhuma responsabilidade pelas conseqüências de quaisquer erros ou
inexatidões que possam aparecer neste documento.
TOTVS S.A.
Av. Santos Dumont, 831, Joinville, SC, Brasil, CEP 89.222-900

2
 Índice

Customização Workflow .................................................................... 4

Propriedades Avançadas ............................................................................... 4
Listeners do Processo ................................................................................... 5
Customização do Processo ......................................................................... 11
Tratamento de Exceções ............................................................................. 12
Mecanismo de Atribuição............................................................................. 13
Como Criar Um Mecanismo de Atribuição .................................................. 14
Parâmetros Workflow para Customização de Fichários .............................. 19
Customização de E-mail .............................................................................. 19

3
 Customização Workflow

Propriedades Avançadas
As propriedades avançadas contêm informações especiais que podem alterar
o comportamento padrão do processo em algum ponto. Elas devem ser
utilizadas principalmente durante a fase de customização ou conter “flags”
especiais que alterem alguma lógica interna (apenas em casos especiais).
Para cadastrar uma propriedade avançada deve-se acessar a opção
“Configuração de Processos” no menu Workflow. Selecione o processo
desejado de acesse a opção “Editar”. A seguinte tela será apresentada:

Clique sobre a aba “Avançado” e será apresentado o cadastro de

“Propriedades Avançadas” do processo. A seguinte tela será apresentada:

4
Use os botões Adicionar, Editar e Excluir para a manutenção dos eventos
desejados. Uma propriedade avançada é representada por nome e valor.
Onde o nome deve ser único. Abaixo o formulário para a criação de uma
propriedade avançada.

Listeners do Processo
Os listeners de um processo são um conjunto de scripts carregados pela API
de workflow. Tais scripts são desenvolvidos com o uso da linguagem
JavaScript e chamados ao longo da execução do processo em um momentos
pré-determinados, como por exemplo a criação de um processo ou a entrada
em uma nova atividade.
No ByYou ECM os listeners são tratados como eventos do processo. Assim,
cada listener é representado por um evento.
Para cria a lista de eventos do processo deve-se acessar a opção
“Configuração de Processos” no menu Workflow. Clique sobre a aba
“Avançado” e posteriormente clique sobre a aba “Eventos”. A seguinte tela
será apresentada.

5
Importante
Em todos eventos do processo é possível obter informações da API de
Workflow. Cada evento possui acesso ao handle da API de workflow através
da variável global “hAPI”. Os seguintes métodos estão disponíveis através da
“hAPI”:
• getCardValue(“nome-campo”): permite acessar o valor de um campo
do ficha do processo;
• setCardValue(“nome-campo”,”valor”): permite definir o valor de um
campo da ficha do processo, onde:
o nome-campo: é o nome do campo da ficha;
o valor: é o valor a ser definido para o campo da ficha;
• setAutomaticDecision(int iTask, List<String> cColab, String cObs):
permite definir o fluxo de saída de uma atividade de forma automática,
onde:
o iTask: é a atividade corrente do processo;
o cColab: é uma lista colaboradores – do tipo String;
o cObs: é a observação;
• getActiveStates(): retorna uma lista de inteiros das atividades do
processo;
• setDueDate(int processInstanceId, int threadSequence, String userId,
Date newDueDate, int timeInSeconds): permite alterar o prazo de
conclusão para um determinada atividade do processo, onde:
o processInstanceId: é o número da solicitação workflow;
o threadSequence: é o número da thread (normalmente 0,
quando não se utiliza atividades paralelas);
o userId: o usuário responsável pela tarefa;

6
 o newDueDate: a nova data de conclusão.
o timeInSeconds: é o tempo que representa a nova hora de
conclusão, calculado em segundos após a meia-noite.
Nos eventos existe a possibilidade de integração com serviços de dados. Tais
serviços podem ser Web Services, AppServer e Dataset.
O acesso a Web Services ou AppServer deve ser previamente configurado
em “Navegação”, na pasta “Painel de Controle” no cadastro de “Serviço de
dados”. Abaixo a tela de configuração dos serviços de dados.

Por exemplo, para criar um Web Service são necessárias as seguintes

informações:
o Nome: o nome do serviço de dados;
o Descrição: a descrição do serviço de dados;
o URL: a URL de do WSDL;
o URI: a identificação.

7
Para realizar a chamada ao Web Service no listener:
var service = serviceManager.getServiceInstance("nome-serviço");
var user = service.execute("nome-operação",null);
Passando parâmetros para o serviço teríamos:
var serviceParams = new java.util.HashMap();
serviceParams.put("nome-parametro","valor");
var service = serviceManager.getServiceInstance("nome-serviço");
var result = service.execute("nome-operação",serviceParams);

Onde a variável “result” receberá uma String representando o resultado da

chamada ao serviço.
No caso do AppServer, são necessárias as seguintes informações:
o Nome: o nome do serviço de dados;
o Descrição: a descrição do serviço de dados;
o URL: a URL de acesso ao AppServer;

8
Para acessar os serviços de dados no evento do listener:
service = serviceManager.getServiceInstance("nome-serviço");
service.getBean();
service.meuMetodo();

Para passar parâmetros deve ser respeito o padrão de conversão de dados

entre Progress e Java. Este padrão é definido pela Progress e o mapeamento
de tipos pode ser encontrado no documento “Open Edge Development: Java
Open Clients” distribuído pela Progress Software.
O resultado de uma chamada ao AppServer deve ser tratado com a classe
ResultSetHolder da Progress.
As chamadas ao AppServer tem como pré-requisito duas bibliotecas Java. A
primeira é a “o4glrt.jar” e a segunda é a biblioteca de conectores do ByYou
ECM cujo nome é “Webdesk3Connectors.jar”. Esta última faz parte da
expedição padrão do ByYou ECM.
Os seguintes eventos são disparados pela API de Workflow:

Evento Descrição
ProcessSet Ocorre quando um processo é “setado” na API.
Parâmetros: Número do processo (INTEGER).
AfterProcessCreate Ocorre logo após a criação de um novo processo.
Parâmetros: Número do novo processo (INTEGER).
BeforeStateLeave Ocorre antes da saída de uma atividade.
Parâmetros: Seqüência da atividade (INTEGER).
afterStateLeave Ocorre após a saída de uma atividade.
Parâmetros: Seqüência da atividade (INTEGER).
BeforeStateEntry Ocorre antes da entrada em uma nova atividade.
Parâmetros: Seqüência da atividade (INTEGER).
AfterStateEntry Ocorre após a entrada em uma nova atividade.
Parâmetros: Seqüência da atividade (INTEGER).
BeforeTaskCreate Ocorre antes que o usuário receba uma tarefa.
Parâmetros: Matrícula do usuário (CHARACTER).
AfterTaskCreate Ocorre após o usuário receber uma tarefa.
Parâmetros: Matrícula do usuário (CHARACTER).
BeforeTaskSave Ocorre antes de salvar as informações selecionadas
pelo usuário.

9
 Parâmetros: Usuário corrente (CHARACTER),
Seqüência da próxima atividade (INTEGER) e lista
de usuários destino (CHARACTER).
AfterTaskSave Ocorre após salvar as informações selecionadas
pelo usuário.
Parâmetros: Usuário corrente (CHARACTER),
Seqüência da próxima atividade (INTEGER) e lista
de usuários destino (CHARACTER).
BeforeTaskComplete Ocorre antes que o usuário complete uma tarefa,
porém as informações de próxima tarefa e
colaboradores destino já foram salvas.
Parâmetros: Usuário corrente (CHARACTER),
Seqüência da próxima atividade (INTEGER) e lista
de usuários destino (CHARACTER).
AfterTaskComplete Ocorre após o usuário completar uma tarefa, porém
as informações de próxima tarefa e colaboradores
destino já foram salvas.
Parâmetros: Usuário corrente (CHARACTER),
Seqüência da próxima atividade (INTEGER) e lista
de usuários destino (CHARACTER).
subProcessCreated Ocorre quando um sub-processo é criado.
Parâmetros: Número do sub-processo (INTEGER).
validateAvailableStates Ocorre após montada a lista de tarefas disponíveis
para o usuário a partir da tarefa atual.
Parâmetros: Seqüência da atividade atual
(INTEGER) e input-output lista das seqüências das
atividades (CHARACTER).
afterProcessFinish Ocorre após finalizada a solicitação.
Parâmetros: Número do processo (INTEGER).
beforeCancelProcess Ocorre antes do cancelamento da solicitação.
Parâmetros: Usuário corrente (CHARACTER) e
Número do processo (INTEGER).
AfterCancelProcess Ocorre após o cancelamento da solicitação.
Parâmetros: Usuário corrente (CHARACTER) e
Número do processo (INTEGER).
AfterRelaseVersion Ocorre após a liberação de uma versão do processo
workflow.
Parâmetros: XML com a definição do processo
(CHARACTER) .
Recomendações:
• Não é necessário criar todos os eventos do processo – apenas
aqueles que se estiver interessado.
• Todos os eventos são executados de forma persistente.
• Importante: Não é possível capturar (hAPI.getCardValue) ou
adicionar (hAPI.setCardValue) dados no fichário na
inicialização do processo. Somente a partir da segunda
tarefa, para isso pode ser utilizado a seguinte lógica:
function beforeStateEntry(sequenceId){
if(sequenceId != “NUMERO_DA_ATIVIDADE_INICIAL” ){
var campo = hAPI.getCardValue(“campo1”);
}
}

10
 Customização do Processo
Com o uso de listeners, o ByYou ECM permite que um processo seja
customizado possibilitando a execução de ações definidas pelo usuário, tais
como:
• Validar o ato de completar uma atividade
• Tomar decisões automaticamente
Exemplo 1:
Para validar se o usuário está completando uma atividade corretamente,
basta utilizar o evento beforeTaskComplete e retornar alguma mensagem
caso queira disparar um erro. Por exemplo, segue parte de um código de
customização criado pelo ByYou ECM:
function beforeTaskComplete(colleagueId,nextSequenceId,userList){
var ativAtual = getValue("WKNumState");
var users = new java.util.ArrayList();
var usersTmp = new java.util.ArrayList();
var cUsers;
var process = parseInt(globalVars.get("process"));
var User1 = hAPI.getCardValue("resp1_H");
var eficacia1 = hAPI.getCardValue("eficaz1");
var controle1 = hAPI.getCardValue("controle1");
var eficaz = true;
var codgrupo;
log.info("ATIVIDADE---> " + ativAtual + " - " + nextSequenceId);

if(ativAtual == 7 && nextSequenceId == 12){

if(User1 != "" && eficacia1 != "1" && eficacia1 != "2"){
if(verificaUsuario(users,User1)){
users.add(User1);
}
}

log.info("TAMANHO VETOR ----> " + users.size());

hAPI.setAutomaticDecision(8, users, "Decisao tomada automaticamente pelo ByYou ECM.");
} else if(ativAtual == 9 && nextSequenceId == 13){
log.info("[1] Usuarios----> " + User1);
log.info("[1] EFICACIA----> " + eficacia1);
log.info("[1] CONTROLE----> " + controle1);

if(User1 != "" && eficacia1 == "2" && controle1 == ""){

eficaz = false;
}

11
 log.info("EFICAZ " + eficaz);

if(eficaz){
log.info("[if1]");
codGrupo = buscaGrupo(process,"Grupo-Qualidade");
log.info("CODIGO GRUPO " + codGrupo);
users.add("Pool:Group:" + codGrupo);
hAPI.setAutomaticDecision(6, users , "Decisao tomada automaticamente pelo ByYou
ECM.");
}
}
}

Exemplo 2:
Para fazer com que uma decisão seja tomada automaticamente, os seguintes
procedimentos devem ser executados:
1. Configurar em Propriedades Avançadas a propriedade
AutomaticTasks – conforme descrito anteriormente – com a lista de
todas as atividades que terão decisão delegada a um listener (Ex.:
AutomaticTasks=3,6,10).
2. Implementar o vento beforeStateEntry e executar e chamar a o
método “setAutomaticDecision” da hAPI, passando como parâmetros
o próximo estado, o próximo usuário (ou lista de usuários) e a
observação.
function beforeStateEntry(sequenceId) {
var userList = new java.util.ArrayList();
userList.add(“Administrator”);
hAPI.setAutomaticDecision(new java.lang.Integer(8), userList, “Observação”);
}

ATENÇÃO: As atividades com decisão automática também podem ser

criadas via editor de processos.
Para maiores informações consulte o Manual de Referência do ByYou ECM.

Tratamento de Exceções
As exceções podem ser tratadas nos seguintes eventos: beforeStateEntry,
beforeTaskSave e beforeCancelProcess. O tratamento da exceção no evento
beforeStateEntry pode ser utilizado somente na inicialização de solicitações,
pois ele impede que a solicitação seja iniciada. O tratamento da exceção no
evento beforeTaskSave pode ser utilizado somente se a solicitação já estiver
inicializada. Abaixo segue os modelos para utilização em cada um dos
eventos:

12
function beforeStateEntry(sequenceId){
var activity = getValue("WKNumState");
if (activity == 0 || activity == 1){
//outra condição.
throw "TRATAMENTO DA EXCEÇÃO"
}
}
function beforeTaskSave(colleagueId,nextSequenceId,userList){
var activity = getValue("WKNumState");
if (activity != 0 && activity != 1){
// outra condição
throw "TRATAMENTO DE EXCEÇÃO";
}
}
function beforeCancelProcess(colleagueId, processId){
// condição.
throw "TRATAMENTO DA EXCEÇÃO"
}

Mecanismo de Atribuição
Os mecanismos de atribuição são instrumentos utilizados durante um
processo de workflow que permitem criar, segundo um critério estabelecido
pelo próprio mecanismo, uma lista de possíveis colaboradores para uma
atividade. Esta lista pode ser utilizada em dois momentos:
1. Na inicialização do processo, onde o sistema verifica se o usuário
corrente faz parte desta lista e, portanto, pode iniciá-lo;
2. No momento do encaminhamento de uma tarefa, quando esta lista é
apresentada ao usuário corrente com opções de encaminhamento da
solicitação.
No primeiro caso, a lista é gerada de acordo com o mecanismo de atribuição
existente na primeira atividade do processo (que representa a atividade de
start). Nas demais atividades é adotado o segundo procedimento. Quando
não houver um mecanismo de atribuição associado a uma atividade (seja ela
inicial ou não), todos os usuários são considerados válidos.
Na inicialização do ByYou ECM são criados alguns mecanismos
automaticamente, conforme abaixo:

Mecanismo Descrição
Associado Permite compor lógicas complexas de atribuição por
intermédio da associação de vários mecanismos.
Campo Formulário Permite atribuir tarefas ao colaborador informado
em um campo do formulário do processo.

13
Executor Atividade Permite selecionar os colaboradores que
executaram uma atividade anterior.
Grupo Permite filtrar apenas os colaboradores que façam
parte de um determinado grupo.
Grupos Colaborador Permite filtrar apenas os colaboradores que
pertençam a um dos grupos do colaborador
corrente, ou do colaborador que iniciou o processo
(solicitante). Também permite filtrar apenas os
colaboradores cujo grupo de trabalho seja o mesmo
do colaborador (corrente ou solicitante).
Papel Permite filtrar apenas os colaboradores que
possuam um determinado papel no Workflow.
Pool Grupo Permite atribuir tarefas a um grupo de
colaboradores e não apenas a um colaborador.
Assim, qualquer um dos colaboradores deste grupo
pode assumir as tarefas para completá-las.
Pool Papel Permite atribuir tarefas a um papel e não apenas a
um colaborador. Assim, qualquer um dos
colaboradores neste papel pode assumir as tarefas
para completá-las.
Usuário Permite atribuir tarefas a um colaborador específico.

Como Criar Um Mecanismo de

Atribuição
O mecanismo de atribuição geralmente é composto de duas partes, a tela de
configuração e o script de resolução do mecanismo de atribuição.

Para criar um mecanismo de atribuição basta acessar o “Painel de Controle”,

na opção “Workflow” e clicar sobre “Mecanismos de Atribuição”. A seguinte
tela será apresentada:

14
A tela apresenta todos os mecanismos de atribuição padrão do ByYou ECM e
também os mecanismos customizados.
Para criar um novo mecanismo de atribuição clique sobre o botão “Adicionar”,
então a seguinte tela será apresentada:

O mecanismo de atribuição deverá possuir obrigatóriamente seu código, o

nome e a descrição da configuração. A tela de configuração é opcional, mas
caso for utilizá-la, deve-se obrigatoriamente importar o componente
AssignmentSelectedEvent.swc que fica dentro do diretorio de instalação do
ByYou ECM (Ex: C:\ByYouEcm\server\default\deploy\Webdesk3EE.ear)
dentro do pacote EAR existe um pacote Webdesk3Web.war, abra o arquivo e
copie o SWC para o seu projeto e importe como biblioteca. Após, sua tela
deve extender o módulo WebdeskModule, veja um exemplo de tela abaixo:

15
<?xml version="1.0" encoding="utf-8"?>
<module:WebdeskModule xmlns:mx="http://www.adobe.com/2006/mxml"
xmlns:module="com.datasul.technology.webdesk.foundation.module.*"
creationComplete="{init();}">

<module:states>
<mx:State name="blocked">
<mx:SetProperty target="{this}" name="enabled" value="false"/>
</mx:State>
</module:states>

<mx:Script>
<![CDATA[
import com.datasul.technology.webdesk.workflow.assignment.event.AssignmentSelectedEvent;
import com.datasul.technology.webdesk.dm.view.event.CloseWindowEvent;
import mx.collections.ArrayCollection;

[Bindable]
private var arr:ArrayCollection = new ArrayCollection([
{value:"asd1",label:"Informática"},
{value:"asd2",label:"RH"},
{value:"asd3",label:"Produto"}]);

private function init():void {

if (super.xmlFromDatabase != null) {
var xml:XML = new XML(super.xmlFromDatabase);
var area:String = String(xml.area);
this.tiNome.text = String(xml.nome);

for each (var current:Object in this.arr) {

if (current.value == area) {
this.cbArea.selectedItem = current;
break;
}
}
}
}

private function saveMecan():void {

var event:AssignmentSelectedEvent = new AssignmentSelectedEvent();
event.xmlString = "<Custom>" +
" <nome>"+this.tiNome.text+"</nome>" +
" <area>"+this.cbArea.selectedItem.value+"</area>" +
"</Custom>";

this.dispatchEvent(event);
this.closeWindow();
}

private function closeWindow():void {

this.dispatchEvent(new CloseWindowEvent());
}
]]>
</mx:Script>

<mx:Form>
<mx:FormItem label="Nome">
<mx:TextInput id="tiNome" width="200"/>
</mx:FormItem>
<mx:FormItem label="Área">
<mx:ComboBox id="cbArea" dataProvider="{arr}"></mx:ComboBox>
</mx:FormItem>
<mx:FormItem direction="horizontal" width="100%">
<mx:Button label="Salvar" click="{saveMecan()}"/>
<mx:Button label="Fechar" click="{closeWindow()}"/>
</mx:FormItem>
</mx:Form>

</module:WebdeskModule>

16
A tela de configuração deverá montar o XML que consiste da configuração do
mecanismo de atribuição. Na resolução de uma atividade do processo o XML
de configuração será enviado ao script de descrição da configuração – é o
último campo da tela. Exemplo baseado na tela acima:

function resolve(process,colleague,configXML){

var newXML = new XML(configXML);

var userList = new java.util.ArrayList();

if (newXML.area.toString()=="asd1") {
userList.add('adm');
} else if (newXML.area.toString()=="asd2") {
userList.add('1');
} else {
userList.add('10');
}

return userList;
}

OBS: É possível acessar Datasets e WebServices apartir da função.

Além do XML o script também recebe como parâmetros o código do processo
e o usuário corrente. Por fim, o script de configuração retorna a lista de
usuários e o fluxo de saída da atividade é selecionado.
Para persistir o XML de configuração criado pela tela basta lançar o evento
AssignmentSelectedEvent e atribuir o XML de configuração na propriedade
“xmlString”.
Dica: caso a compilação normal pela GUI de desenvolvimento não esteja
efetuando as importações corretamente, segue sugestão de compilação do
projeto:
mxmlc -debug=false -optimize=true -warnings=false -load-config flex-
config-mxmlc.xml -source-path=. <ARQUIVO>.mxml -output
<ARQUIVO>.swf

17
 Arquivo FLEX-CONFIG-MXMLC.XML:

<?xml version="1.0" encoding="utf-8"?>

<flex-config xmlns="http://www.adobe.com/2006/flex-config">

<metadata>
<title>By You ECM</title>
<language>EN</language>
</metadata>

<compiler>

<fonts>
<local-fonts-snapshot>C:/Arquivos de programas/Adobe/Flex Builder 3
Plug-in/sdks/2.0.1/frameworks/localFonts.ser</local-fonts-snapshot>
</fonts>

<!-- list of SWC files or directories that contain SWC files -->
<library-path>
<path-element>C:/Arquivos de programas/Adobe/Flex Builder 3 Plug-
in/sdks/2.0.1/frameworks/libs</path-element>
<path-element>C:/Arquivos de programas/Adobe/Flex Builder 3 Plug-
in/sdks/2.0.1/frameworks/locale/en_US</path-element>
<path-element>AssignmentSelectedEvent.swc</path-element>
</library-path>

<debug>true</debug>
</compiler>
<use-network>true</use-network>
</flex-config>

Por fim, o arquivo SWF do mecanismo de atribuição deve ser publicado no

ByYou ECM como um documento. Para selecionar o documento no momento
da publicação basta clicar sobre o ícone ao lado do campo “Tela de
Configuração”.

18
Parâmetros Workflow para Customização de
Fichários

Para processos que possuem um fichário padrão definido são passados

alguns parâmetros com informações sobre o processo para serem utilizados
nas customizações do fichário, conforme abaixo:
Parâmetro Descrição
WKDef Código do processo
WKVersDef Versão do processo
WKNumProces Número do processo
WKNumState Número da atividade
WKCompany Número da Empresa
WKUser Usuário Corrente

Estas informações são passadas como parâmetros da URL do programa que

permite o encaminhamento das atividades, portanto no programa de
customização do fichário basta recuperar as informações com o comando
getValue, conforme exemplo:

var vCodProcess = getValue("WKDef");

Customização de E-mail

É possível incluir customizações de e-mail durante o andamento de um

Workflow. Existem duas modalidades de customização nessa categoria:

1. Envio e alteração de e-mail padrão através do evento

onNotify.
2. Envio de e-mail customizado em qualquer evento do
Workflow.

Envio de E-mail Padrão

Para interferir no envio de um e-mail padrão, deve ser utilizado o evento

onNotify, que é disparado no exato momento em que qualquer um dos e-mails
de processo é enviado. Nesse evento, podem ser feitas alterações, como por
exemplo: adicionar outros destinatários ao e-mail (além daqueles que estão
participando do processo), modificar os valores dos parâmetros utilizados no
template de e-mail, etc.
Abaixo encontra-se um exemplo de como implementar esse evento.

function onNotify(subject, receivers, template, params){

if(template.match("tpl028")!=null){
receivers.add("usuario@dominio.com");
}

19
}

O evento onNotify está disponível na lista de eventos do Workflow. Portanto,

ao selecionar esse evento na lista de eventos disponíveis, a assinatura da
função acima já será preenchida automaticamente.
Este evento disponibiliza os seguintes parâmetros:

3. Subject: É o assunto do e-mail. A alteração desta variável irá implicar

que todos os usuários recebam o e-mail com o novo assunto
configurado, inclusive aqueles que participam do processo. Exemplo
de utilização: subject.add("ASSUNTO");
4. Receivers: Lista de e-mails destinatários. Também é possível
adicionar outros e-mails, de usuários que não participam do workflow.
Inclusive, podem ser adicionados e-mails de usuários que não estão
cadastrados no ByYou ECM, caso seja necessário notificar uma
pessoa que não tenho acesso ao sistema.
5. Template: Permite validar qual tipo de e-mail está sendo enviado (por
exemplo, template de nova tarefa, notificação de gestor, etc). Com
base nessa variável podemos distinguir quais e-mails queremos
customizar. É recomendável que sempre seja verificado o código do
template, para evitar que ocorram alterações em outros tipos de e-
mail, que não necessitariam de customização.
6. Params: É um mapa de dados que permite alterar/incluir parâmetros
para que sejam apresentados no e-mail. O nome dos parâmetros
informados nesse mapa devem ser os mesmos que são utilizados
dentro do arquivo de template.

No exemplo que foi apresentado acima está sendo validado se o template é o

TPL028 (que corresponde a Notificação do Gestor), em caso positivo, um
novo e-mail será adicionado na lista de destinatários. Ou seja, além do gestor
do processo, uma outra pessoa será notificada, recebendo uma cópia do e-
mail que o gestor irá receber. Como está sendo validado o código do
template, os demais tipos de e-mail não serão afetados.
Os templates podem ser consultados dentro do diretório do volume, em:
<VOLUME>\templates\tplmail. Se for necessário adicionar algum parâmetro
no e-mail padrão, os templates podem ser editados diretamente nesse
diretório.
Obs.: No evento onNotify é possível utilizar apenas o objeto “log”.

Envio de E-mail Customizado

Caso seja necessário incluir um novo tipo de e-mail, além daqueles que são
disponibilizados pelo produto, o ByYou ECM permite que o usuário cadastre
templates customizados, através do ícone “Templates” na categoria GED ou
Painel de Controle, na tela principal do sistema.

20
Para incluir um novo Template, basta clicar no botão adicionar e preencher os
dados solicitados. Nesta etapa também deve ser feito upload do arquivo de
template.

Para adicionar parâmetros dentro de um arquivo de template (TXT ou HTML),

deve-se utilizar a seguinte notação:

${NOME_USUARIO}

Neste caso, será utilizado o o identificador “NOME_USUARIO” durante a

customização para atribuir um valor a este parâmetro.
Os templates disponíveis no volume da empresa
(<VOLUME>\templates\tplmail) podem ser consultados para mais exemplos
de utilização de parâmetros.

Após cadastrar um novo template, é possível utilizá-lo para enviar e-mail a

partir de qualquer um dos eventos do Workflow (exceto no onNotify – ver
“Envio de E-mail Padrão”).
Para efetuar um envio de e-mail, em base de um template customizado, é
utilizado o objeto “notifier”, chamando a função “notify”, conforme o código
abaixo:

try{
//Monta mapa com parâmetros do template
var parametros = new java.util.HashMap();
parametros.put("NOME_USUARIO", "JOAO");
parametros.put("CODIGO_USUARIO", "01");

//Este parâmetro é obrigatório e representa o assunto do e-mail

parametros.put("subject", "ASSUNTO");

//Monta lista de destinatários

var destinatarios = new java.util.ArrayList();
destinatarios.add("MATRICULA-DESTINATARIO");

//Envia e-mail
notifier.notify("MATRICULA-REMETENTE", "CODIGO-TEMPLATE",
parametros, destinatarios, "text/html");

}catch(e){
log.info(e);
}

O primeiro parâmetro que a função notify recebe é o código/matrícula do

usuário que irá enviar o e-mail (remetente).
O segundo parâmetro é o código do template que foi cadastrado através do
ícone de Templates.

21
O terceiro parâmetro é um mapa de dados (java.util.HashMap) que contém os
parâmetros que serão utilizados para preencher as variáveis do template.
O quarto parâmetro representa a lista de usuários que irão receber o e-mail
(java.util.ArrayList). Esta lista de usuários consiste em uma lista de
códigos/matrículas de colaboradores cadastrados no ByYou ECM.
O quinto e último parâmetro especifica qual será o formato do e-mail enviado.
Os valores aceitos são “text/html” e “text/plain”.

22