Índice

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).

Eventos do Processo

Os eventos 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.

Nos eventos existe a possibilidade de integração com serviços de dados. Tais serviços podem ser WebServices, AppServer Progress® e Dataset.
O acesso a WebServices ou AppServer Progress® deve ser previamente configurado no cadastro de Serviços. Para mais detalhes consulte o Guia de Integração ECM, no capítulo “Acessando WebServices a partir do TOTVS | ECM“.
Abaixo um exemplo de como executar o WebService de Colleague para criar um usuário após executar uma tarefa:

Os seguintes eventos são disparados pela API de Workflow:

Customização de Processo

Com o uso de eventos, o 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

Existem algumas propriedades que contém informações referentes à solicitação que podem ser utilizadas na customização do processo, são elas:

Além dessas propriedades já alimentadas pelo produto, é possível criar propriedades customizadas que podem ser utilizadas nos eventos.
O produto disponibiliza a variável globalVars, que é um mapa de dados (HashMap<String, String>) e estará disponível em todos os eventos.
Para adicionar uma propriedade e seu valor, utilize o método: globalVars.put("name", "value"). Onde name é o nome da propriedade e value o seu valor. Ex: globalVars.put("WDAprovador","adm");
Para recuperar os valores da variável globalVars, utilize o método: globalVars.get("name");
Onde "name" é o nome da propriedade a ser retornado o valor. Ex: globalVars.get("WDAprovador");

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 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 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;
}
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 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 via customização (Ex.: AutomaticTasks=3,6,10).
2. Implementar o evento 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 mais informações consulte o Manual de Referência do ECM.

Exemplo 3:
Para iniciar uma nova solicitação de um outro processo ao finalizar uma solicitação devem ser executados os seguintes procedimentos:
1. Criar um serviço no ECM em que a URL seja o webservice de WorkflowEngineService .
(Ex.: http://localhost:8080/webdesk/WorkflowEngineService?wsdl )
2. Implementar o evento afterProcessFinish utilizando o exemplo abaixo. Sendo ‘process2’ o novo processo a ser inicializado.

function afterProcessFinish(processId){
var func = { run: function(){
a();
}
};
var r = new java.lang.Runnable(func);
var t = new java.lang.Thread(r);
t.start();
log.info("Iniciei a thread");
return;
}
function a(){
try {
var atividade = getValue("WKNumState");
var user = getValue("WKUser");
var processo = getValue("WKNumProces");
log.info("########## Atividade: " + atividade);
log.info("########## inicio webservice workflow");
var workflow = ServiceManager.getService("WorkflowEngineService");
var serviceHelper = workflow.getBean();
var serviceLocator = serviceHelper.instantiate("com.datasul.technology.webdesk.workflow.ws.WorkflowEngineServiceServiceLocator");
var service = serviceLocator.getWorkflowEngineServicePort();
log.info("########## carregou serviço workflow");
log.info("########## Carrega Colaboradores do segundo processo");
var stringArray = service.getAvailableUsersStart("adm", "adm", 1, "process2", 0, 0);
var field1 = serviceHelper.instantiate("com.datasul.technology.webdesk.workflow.ws.KeyValueDto");
field1.setKey("nome");
field1.setValue("valorNome");
var field2 = serviceHelper.instantiate("com.datasul.technology.webdesk.workflow.ws.KeyValueDto");
field2.setKey("cid");
field2.setValue("valorCidade");
var resultArr = serviceHelper.instantiate("com.datasul.technology.webdesk.workflow.ws.KeyValueDtoArray");
resultArr.setItem(new Array(field1, field2));
log.info("########## Inicia StartProcess");
var userArray = serviceHelper.instantiate("net.java.dev.jaxb.array.StringArray");
userArray.setItem(new Array(user));
log.info("########## Usuario: " + userArray.getItem(0));
try {
var ret = service.startProcessClassic("adm", "adm", 1, "process2", 2, userArray , "webservice chamada", "adm", false, null,resultArr, null, true);
} catch(e) {
log.info("########## Erro startProcess: " + e);
}
} catch(x) {
log.info("########## Erro Process: " + x);
}
}

Tratamento de Excessõ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:

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"
}

É possível consistir o campo observação de uma solicitação workflow, verificando se ele foi preenchido ou não. Para isto, é necessário validar a propriedade WKUserComment no evento beforeTaskSave ou no evento beforeCancelProcess.

function beforeTaskSave(colleagueId,nextSequenceId,userList){
if(getValue("WKUserComment")==null || getValue("WKUserComment")=="")
throw "A observação deve ser preenchida";
}
function beforeCancelProcess(colleagueId,processId){
if(getValue("WKUserComment")==null || getValue("WKUserComment")=="")
throw "A observação deve ser preenchida";
}

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 ECM são criados alguns mecanismos automaticamente, conforme abaixo:

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.

<?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>

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;
}

Arquivo FLEX-CONFIG-MXMLC.XML:

<?xml version="1.0" encoding="utf-8"?>
<flex-config xmlns="http://www.adobe.com/2006/flex-config">
<metadata>
<title>TOTVS | 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 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”.

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:

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:

• Envio e alteração de e-mail padrão através do evento onNotify.
• 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 se encontra um exemplo de como implementar esse evento.

function onNotify(subject, receivers, template, params) {
if (template.match("tpl028")!=null) {
receivers.add("[email protected]");
}
}

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:

1. 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");
2. 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       ECM, caso seja necessário notificar uma pessoa que não tenho acesso ao sistema.
3. 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.
4. 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, 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.

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 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.

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 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.

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.

Por padrão, os parâmetros WDK_VirtualDir (diretório virtual) e WDK_AdviceUser (Nome do colaborador remetente) são adicionados ao mapa de parâmetros automaticamente e podem ser utilizados na template, sem que os valores sejam adicionados pela customização.

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 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”.

Outra forma de executar o método de envio de email é informando o número da ficha, conforme exemplo:

notifier.notify("MATRICULA-REMETENTE", NÚMERO DA FICHA, "CODIGO-TEMPLATE", parametros, destinatarios, "text/html");

Ao executar este método, automaticamente os parâmetros abaixo serão adicionados a lista de parâmetros e podem ser utilizados na template: