treinamento em bpm e automação de...

Treinamento em BPM

e Automação de

Processos

2

Objetivo

O objetivo deste material é proporcionar uma visão sobre os conceitos do BPM, sua

aplicação conceitual e como realizar as automações de processos no Ágiles.

Após o treinamento, você será capaz de mapear os processos de negócio, criar sua

documentação e automatizá-lo.

3

Sumário Objetivo ......................................................................................................................................... 2

Notação BPMN – Business Process Modeling Notation ............................................................... 7

Apresentação e explicação de cada elemento do BPMN ......................................................... 8

Criando Processos (New Process) ............................................................................................. 8

Editor de Expressões ............................................................................................................... 10

Construindo o Mapa do Processo ........................................................................................... 18

Ferramentas para Desenhar o Processo ................................................................................. 22

Propriedades da Ferramenta "Início" ..................................................................................... 27

Propriedades da Ferramenta "Evento" ................................................................................... 29

Propriedades da Ferramenta "Fim" ........................................................................................ 35

Propriedades da Ferramenta "Atividade de Usuário" ............................................................ 38

Propriedades da Ferramenta "Atividade Automática" ........................................................... 44

Propriedades da Ferramenta "Notificação" ............................................................................ 47

Propriedades da Ferramenta "Sub-Processo"......................................................................... 50

Propriedades da Ferramenta "Gateway" ................................................................................ 53

Propriedades da Ferramenta "Pool" ....................................................................................... 57

Propriedades da Ferramenta "Anotação" ............................................................................... 59

Artefato ................................................................................................................................... 60

Grupo....................................................................................................................................... 60

MGP – Metodologia em gestão de projetos de BPM.................................................................. 62

Técnicas de levantamento/analise .......................................................................................... 62

Documentação padronizada ................................................................................................... 62

Exercício .................................................................................................................................. 63

Melhoria contínua de processo .............................................................................................. 65

HTML Form .................................................................................................................................. 67

Estrutura .................................................................................................................................. 67

Como criar Arrays em HtmlForms ........................................................................................... 67

Choose ......................................................................................................................................... 69

Tipos de choose disponibilizados: ........................................................................................... 70

4

Anexar arquivos........................................................................................................................... 70

Variáveis de processo .............................................................................................................. 72

Metadados .................................................................................................................................. 73

Definindo Metadados.............................................................................................................. 73

Buscando Metadados .............................................................................................................. 73

Listando Metadados de um Item ............................................................................................ 73

Visitor .......................................................................................................................................... 74

Publicação ............................................................................................................................... 74

Jython para Ágiles ....................................................................................................................... 75

Comparação Java/Jython ........................................................................................................ 76

Operadores Lógicos / Aritméticos ....................................................................................... 76

Blocos de Controle .............................................................................................................. 77

Declarações ......................................................................................................................... 77

Métodos de String ............................................................................................................... 78

Listas .................................................................................................................................... 78

Dicionários ........................................................................................................................... 79

Exemplos ............................................................................................................................. 79

Integração Java/Jython ....................................................................................................... 79

Integração com Ágiles ............................................................................................................. 80

Uso de variáveis do processo .............................................................................................. 80

Chamada de Functions ........................................................................................................ 80

Disparando sub processos ................................................................................................... 80

Como fazer a manutenção dos processos desenvolvidos ....................................................... 81

WEB Form .................................................................................................................................... 95

Configuração do ambiente ...................................................................................................... 95

Maven .................................................................................................................................. 95

Projeto ................................................................................................................................. 97

Functions ............................................................................................................................. 97

Model .................................................................................................................................. 97

Service ................................................................................................................................. 98

View ..................................................................................................................................... 99

5

Injeção de Dependências .................................................................................................. 101

Jboss / Ágiles ......................................................................................................................... 102

Desenvolvimento do projeto ................................................................................................ 103

Criação de uma nova entidade.......................................................................................... 103

Criação de atividade de usuário ........................................................................................ 107

Camadas de Serviço .................................................................................................................. 108

Funções ..................................................................................................................................... 109

BasicRoles .............................................................................................................................. 109

Conversion............................................................................................................................. 110

Date ....................................................................................................................................... 111

Form ...................................................................................................................................... 112

ItemFunctions ....................................................................................................................... 113

ItemMetaData ....................................................................................................................... 113

Logic ...................................................................................................................................... 114

Math ...................................................................................................................................... 115

PropertiesFunctions .............................................................................................................. 115

Util ......................................................................................................................................... 115

WS-Function .............................................................................................................................. 118

Criação de uma função que será chamada pelo Ágiles ......................................................... 118

Exemplo de interface: ....................................................................................................... 118

Exemplo de implementação: ............................................................................................. 118

Exemplo do arquivo agiles.xml:......................................................................................... 119

Exemplo do binding no Guice: .......................................................................................... 119

Exemplo da publicação do serviço: ................................................................................... 120

Exemplo da configuração de autenticação: ...................................................................... 120

Object Type ............................................................................................................................... 122

Lista de Atributo .................................................................................................................... 122

Lista de Ações ........................................................................................................................ 124

Lista de Eventos Temporais ................................................................................................... 126

Lista de Telas ......................................................................................................................... 127

Lista de Fases ......................................................................................................................... 127

6

Admin Commands ..................................................................................................................... 130

Como criar adminConsoleCommands ................................................................................... 130

Exemplo de adminConsoleCommand ............................................................................... 130

Nós Organizacionais .................................................................................................................. 132

Dimensões e Níveis Organizacionais ..................................................................................... 132

Estrutura Organizacional ....................................................................................................... 134

Módulos Externos ..................................................................................................................... 136

Ldap ........................................................................................................................................... 137

Especificação ......................................................................................................................... 137

Procedimento de Instalação ................................................................................................. 138

Configuração do Ágiles LDAP Connector............................................................................... 138

LDAP Login Manager ......................................................................................................... 138

Default Configs .................................................................................................................. 139

Groups ................................................................................................................................... 139

Nodes .................................................................................................................................... 141

Users ...................................................................................................................................... 143

Configuração do User Setup .................................................................................................. 145

Anexo A ..................................................................................................................................... 147

Atualizações .............................................................................................................................. 149

Objetivo do Processo ................................................................................................................ 150

Mapa do Processo ..................................................................................................................... 151

Dimensões e Nós Organizacionais ............................................................................................ 153

Grupos ................................................................................................................................... 154

Formulário do Processo ............................................................................................................ 155

Descrição dos Campos do Formulário ................................................................................... 157

ObjectType Template ................................................................................................................ 159

Descrição das Atividades / Tarefas / Transições ....................................................................... 161

7

Notação BPMN – Business Process Modeling Notation

O ÁGILES é um sistema de BPMS (Business Process Management System - Sistema de

Gerenciamento de Processos de Negócio), totalmente desenvolvido no Brasil. Possui recursos

únicos que permitem à empresa modelar, automatizar, integrar e gerir seus processos de

negócios com rapidez, qualidade e custos compatíveis com a nossa realidade.

Os profissionais de processos podem criar/documentar as tarefas e atividades com a

notação BPMN (padronizada pelo BPMI – Business Process Management Initiative), que é

universal e de fácil entendimento. De maneira simples, o profissional associa as tarefas,

atividades, autores e formulários eletrônicos às regras de negócios que regem a execução do

processo específico.

O ÁGILES é totalmente utilizado via internet, permitindo que os participantes no

processo recebam de forma pró-ativa as atividades e tarefas a serem executadas, bem como a

descrição dos formulários eletrônicos e as regras de negócios que regem a execução do

processo específico.

8

Apresentação e explicação de cada elemento do BPMN

Nas próximas sessões serão apresentadas e explicadas cada elemento do BPMN. Com

esses elementos será possível desenhar modelos de negocio que serão automatizado pelo

Ágiles.

Criando Processos (New Process)

Para criar novos processos (independente se o mapa será desenhado aqui ou importado) deve-se clicar em Novo Processo no módulo Desenho de Processos. Surgirá a tela "Propriedades do Processo":

Na figura, em vermelho, foram incluídas pequenas descrições das finalidades de cada campo, e a seguir estão maiores explicações sobre cada um deles.

Nome: nome do processo. Deve ser curto, porém explicativo, pois é através deste nome que localizaremos o processo dentro das categorias.

9

Nome da Instância: para processos que são executados manualmente a partir da Área de Trabalho, podemos especificar o nome padrão para as instâncias do mesmo. Essa informação é opcional e, quando não existir, o usuário deverá especificar o nome da instância no momento que executar o processo.

Descrição: descrição do processo. Embora cada atividade/tarefa possa ter uma descrição específica, a descrição do processo deve ser a mais abrangente possível, dando uma visão geral de tudo que ele fará.

Categoria: categoria a que o processo pertence. Clique em "Procurar" e escolha uma categoria existente (lembrando que as categorias são criadas no módulo “Administração” e visualizadas no comando Categorias do Desenho de Processos). Após a criação do processo, seus testes e alterações serão feitos sempre através do comando Categorias do módulo atual.

Formulários: relação de TODOS os formulários envolvidos neste processo (independente da atividade/tarefa em que são utilizados). É importante lembrar que, para que o formulário possa ser adicionado neste campo, ele deve ter sido incluído no ÁGILES conforme descrito no comando Repositório de Formulários deste módulo.

Referência: tempos estimados para execução desse processo. Podem ser medidos em minutos, horas ou dias.

Tempo Total: tempo total - do início ao final da execução. Tempo Ocioso: tempo ocioso (entre tarefas/atividades) e de processamento

(tarefas executadas automaticamente pelo sistema). Tempo Humano: tempo gasto em atividades/tarefas que exigem interação

humana. Benchmark/Tempo Total: tempo utilizado por processos existentes no mercado (para

comparação). Responsável pelo Processo: também chamado "Process Owner", é a pessoa (ou

pessoas) responsável pela existência e execução do processo, mesmo que não realize qualquer atividade dentro dele. Clique no "+" e escolha, dentre os usuários cadastrados, aqueles que deseja incluir (lembrando que o cadastramento de usuários ocorre no módulo “Administração”).

Criar Processo: grava as propriedades do processo e abre a tela para o desenho do mesmo ("applet"). Caso o mapa do processo deva ser importado e não desenhado, feche a tela do applet e proceda como descrito na visualização de versões (comando Categorias do módulo atual).

Terminado o preenchimento das propriedades (a categoria e o responsável pelo processo são obrigatórios; e o nome, apesar de não ser obrigatório, é altamente recomendável que seja especificado), clique em "Criar Processo". O ÁGILES abrirá a tela ("applet") para que seja desenhado o mapa do processo. Como a explicação deste tópico é bastante extensa será feita no item "Construindo o Mapa do Processo".

10

Editor de Expressões Dentro do Process Designer (a ser explicado mais adiante) ao se tentar editar uma

ação de atividade você provavelmente irá se deparar com o editor de expressão do Ágiles, ele

tem por objetivo fornecer ao desenvolvedor uma forma direta de implementar as regras de

negócio descritas e o funcionamento das atividades do processo.

O Editor de Expressões possui 3 abas principais:

Básico. Para ações que envolvem tempo, o Ágiles irá exibir uma aba onde será possível

informar de forma simples quanto tempo o evento deve aguardar até que seja ativada

sua execução.

11

Script. Nesta aba é permito a programação livre para se atingir o objetivo da atividade.

Caso seja necessário retornar um valor, como por exemplo: uma data, uma Url, um

Grupo de usuários dentre outras situações, Basta definir a variável result com o valor

de retorno.

12

Avançado, Nesta aba será disponibilizada duas janelas, uma com a expressão sendo

editada, e outra janela contendo 7 (sete) abas auxiliares. Abaixo destas janelas

aparecerá o botão ‘<<’ que envia o objeto selecionado para a janela principal que fica

a esquerda. As abas auxiliares serão explicadas a seguir.

Avançado/Variável: Contem as variáveis do processo. Caso clique 2x em qualquer uma

destas variáveis, serão exibidos os atributos o objeto selecionado

o Initiator: Usuário que iniciou a execução do processo.

o Process: Corresponde a instancia do processo em execução.

o Now: Date contendo o TimeStamp no servidor do Ágiles.

o CurrentActivity: Instancia da atividade atual.

o Form(xxxx): É informado quando o processo possui um HtmlForm vinculado,

onde xxxx será preenchido com o nome do formulário.

13

Avançado/Cast: Caso o retorno esperado seja de um tipo especifico, você poderá

realizar um cast para este objeto.

14

Avançado/Script: Permite adicionar código de programação a expressão que está

sendo criada.

15

Avançado/XML: Permite a criação da expressão diretamente em XML para o process.

16

Avançado/Constante: Permite a utilização de constantes dentro do editor de

Expressão.

17

Avançado/Função: Permite a utilização de bibliotecas de função dentro do Editor de

Expressão para a realização das ações necessárias para a atividade.

18

Construindo o Mapa do Processo

Ao criar um novo processo ou alterar um já existente, o ÁGILES abrirá a tela ("applet") que permite a construção do mapa.

Essa tela é dividida nas partes:

Visualização: fica no canto superior esquerdo e permite visualizar o mapa do processo em um Zoom entre 1% e 90% do tamanho real.

Figuras/Propriedades: fica no canto inferior esquerdo. A aba "Figuras" apresenta as ferramentas (objetos) para o desenho do mapa do processo, divididas por categorias. A aba "Propriedades" permite que se configure o objeto do mapa que estiver selecionado no momento (na área de desenho) ou, caso nenhum objeto esteja selecionado, permite a configuração das propriedades do processo como um todo (nome do processo, das instâncias, definições dos esquemas para mensagens).

Área para desenho do mapa do processo: é a área quadriculada do lado direito da tela. O tamanho do processo não precisa se limitar à área visível no momento, as barras de rolagem estarão sempre disponíveis para permitir a visualização de outras partes do mapa. As formas de se desenhar o processo estarão especificadas na descrição das ferramentas.

Barra de menus: localiza-se acima da área de desenho e são formadas pelos menus Salvar, Exibir e Layout. Seus conteúdos serão detalhados a seguir.

19

Problemas: localizada abaixo da área de desenho, exibe os problemas detectados pelo ÁGILES no momento em que o processo é validado (a validação será explicada quando forem detalhados os comandos do menu). Essa parte da tela pode ou não estar sendo exibida, a seta para baixo (acima do rótulo "Problemas") oculta-a e a seta para cima reexibe-a. Em sua listagem, problemas simbolizados em vermelho são itens críticos, que precisam ser resolvidos para que o processo possa ser salvo com validação. Problemas indicados em amarelo são "alertas", ou seja, não impedem a validação do processo, mas podem gerar erro em sua execução.

Para obter detalhes sobre as ferramentas para o mapeamento do processo, consulte o tópico "Ferramentas para Desenhar o Processo" ou clique sobre a área Figuras/Propriedades na imagem ou nas explicações acima.

A barra de menus está detalhada a seguir.

Menu SALVAR: possibilita gravar, validar, exportar e importar o mapa do processo. É composto pelos comandos a seguir.

Salvar: salva o mapa sem validá-lo (recomendável quando o fluxo está incompleto).

20

Validar e Salvar: valida o mapa (verifica se as propriedades de todos os elementos foram definidas e se não há conflito no desenho) e o salva. Deve ser feito quando o mapa estiver completo.

Validar: valida o mapa (faz as consistências) sem salvá-lo. É interessante para verificar se há alguma inconsistência no mapa enquanto o mesmo está sendo desenhado/alterado.

Salvar em XML: salva (exporta) o mapa no formato XML. Salvar Imagem: salva (exporta) uma imagem do mapa. Permite os formatos

JPG e PNG. Salvar documento: Serve para salvar a documentação do processo Importar XPDL: Importa um arquivo padrão XPDL

Exportar XPDL: Exporta o fluxo no padrão XPDL

21

Menu EXIBIR: possibilita imprimir o mapa, exibir a grade na tela e/ou na impressão, e gerar a documentação do processo. É composto pelos comandos a seguir.

Imprimir: imprime o mapa. Permite escolha da orientação da página (rotacionada ou não), se a impressão deve ser feita com ou sem a documentação (vide item "documentação" a seguir), margens de impressão, impressora a ser utilizada e configuração de suas propriedades.

Grade: oculta/exibe a grade na área de desenho. Grade de Impressão: oculta/exibe a grade na impressão do mapa. Documentação: exibe, em tela, uma documentação do processo contendo os

nomes das atividades, decisões (gateways) e sub-processos, com suas descrições, divididos por tipo de objeto (atividade manual, atividade automática, etc.). No caso de atividades manuais, são exibidos os nomes e descrições de suas tarefas também.

Menu LAYOUT: possibilita o alinhamento, seleção e cópia dos objetos existentes no mapa do processo. É composto pelos comandos a seguir.

Comandos de alinhamento: alinham os objetos selecionados de acordo com a posição escolhida (esquerda, vertical, direita, etc.). Para selecionar os objetos, clique sobre os itens desejados enquanto mantém a tecla SHIFT pressionada.

Copiar: gera uma cópia, no mapa atual, dos itens selecionados. É equivalente aos comandos Copiar e Colar do Windows.

22

Mesmo Tamanho: ajusta os objetos selecionados para ficarem do tamanho do primeiro que foi marcado.

Selecionar Todos: seleciona todos os objetos do mapa.

Atenção! É necessário tomar muito cuidado ao executar os comandos do menu Layout, pois eles alteram o mapa do processo e não há um comando para desfazer essas operações.

Ferramentas para Desenhar o Processo

Para criar o mapa do processo, existem diversas ferramentas divididas por categoria. Todas podem ser acessadas através da aba "Figuras".

As categorias e suas ferramentas estão detalhadas a seguir. Construa o mapa utilizando as ferramentas necessárias e, de tempos em tempos, salve-o. Quando o mesmo estiver completo, valide-o e salve (lembre-se que, se desejar, também é possível validar o mapa sem salvá-lo).

Categoria CONEXÕES: possui ferramentas para selecionar e conectar objetos no mapa do processo.

23

Ferramenta de Seleção: para selecionar um objeto, clique sobre ele com esta ferramenta. Para marcar vários objetos, selecione a ferramenta e faça um "retângulo" abrangendo todos os itens desejados, ou mantenha a tecla SHIFT pressionada e clique sobre eles.

Transição: conecta dois elementos do mapa, indica a direção do fluxo e, no caso de iniciar em uma atividade de decisão ("Sincronização"), estabelece a condição para cada um dos desvios/caminhos necessários. Para desenhá-la, selecione a ferramenta e faça uma reta do centro do primeiro elemento até o centro do segundo. O ÁGILES corrige a seta para que ligue as bordas dos dois elementos.

Fluxo de Mensagem: uma mensagem é uma requisição (envio ou solicitação de informação) que é feita utilizando uma aplicação externa ou função do ÁGILES, e permite enviar um XML para um Web Service (conjunto de operações/métodos que podem ser acessados remotamente). Na prática, o uso de mensagens é uma maneira de trocar informações (enviar/receber) entre processos ou aplicações diferentes.

Associação: é representada por uma linha pontilhada, e é usada para associar dados, texto e outros Artefatos aos objetos de fluxo.

Categoria ATIVIDADES: possui as ferramentas para o desenho das atividades, eventos, decisões, raias e anotações no mapa do processo.

24

Ferramenta de Seleção: permite selecionar objetos no mapa. Vide mais explicações na "Categoria CONEXÕES" (acima).

Início: representa o início do mapa. Podem existir vários em um processo, desde que representem situações diferentes (por exemplo, um início "normal" e um que depende de uma regra específica). Para desenhar este símbolo, clique na ferramenta e, depois, clique em qualquer parte da área de desenho. Não é possível especificar o tamanho deste símbolo.

Evento: representa eventos intermediários, isto é, ocorrências no processo em andamento; sendo que o evento pode notificar ou ser notificado dessas ocorrências (por exemplo: que chegou uma data para o decurso de prazo de uma atividade). A regra/condição para que o evento aconteça é especificada no próprio evento. Para desenhar este símbolo proceda como na ferramenta "Início". Também não é possível especificar seu tamanho.

Fim: indica o final do processo e podem existir vários no mesmo mapa. Para desenhá-lo, proceda como na ferramenta "Início".

Atividade de Usuário: atividade que exige interação humana. Para desenhá-lo, selecione a ferramenta e, na área de desenho, faça um retângulo do tamanho desejado.

Obs.: todas as demais ferramentas seguirão esta forma de desenho.

25

Atividade Automática: atividade completamente executada pelo sistema.

Notificação: notificação/mensagem formal envia e-mail para o usuário especificado.

Sub-Processo ("+" e "-"): representa um processo iniciado a partir de outro. Apesar do sub-processo também poder ser iniciado por uma atividade automática, é recomendável que se use a ferramenta de "sub-processo", pois assim o ÁGILES controla o que acontece nesse sub-processo e, quando o mesmo for concluído, informa o processo principal.

Quando o sub-processo possui o sinal "-" na parte inferior, significa que ele está expandido, isto é, seu conteúdo é exibido no mapa atual. Quando possui o símbolo "+", significa que seu conteúdo está representado em outro mapa.

Gateway: divisão ou união de diversos caminhos. O que essa ferramenta representa será especificado pelas propriedades da mesma.

A divisão equivale a uma decisão, ou seja, divide o fluxo em quantos caminhos forem necessários. Apesar de precisar ser representada, esta atividade não contém as condições do desvio, as quais são especificadas na ferramenta "Transição".

O gateway, propriamente dito, é a união dos caminhos. Ela fica em execução até que todas as atividades que "chegam" nela estejam concluídas e, então, permite que o fluxo "siga adiante".

Raia: identifica "players", ou seja, departamentos/empresas/locais diferentes envolvidos no processo. A raia deve envolver todo o fluxo pertencente àquele "player".

Anotação: comentários/anotações no mapa. Apesar de possível, é recomendável que existam poucos comentários para não "poluir visualmente" o mapa.

Artefato: representa artefatos de input ou output no fluxo. Grupos: o agrupamento pode ser usado para fins de documentação ou de

análise, mas não afetam o Fluxo de Sequência.

Categoria de Serviços: As atividades dessa categoria foram descontinuadas e permanece no produto para mantar compatibilidade com fluxos antigos. Porem essas atividades não deve ser usadas nos novos fluxos.

Categoria OUTROS: essa categoria possui apenas a "Ferramenta de Seleção", que já foi explicada anteriormente. Essa categoria existe prevendo que novas ferramentas podem ser incluídas em versões futuras do ÁGILES.

26

Com exceção da "Ferramenta de Seleção", todas permitem a configuração de suas propriedades.

Para visualizar tais propriedades, selecione o objeto desejado no mapa do processo (não adianta apenas selecionar a ferramenta na aba "Figuras") e clique na aba "Propriedades" (à direita de "Figuras").

Neste manual, para visualizar as explicações dessas propriedades, clique sobre o nome ou desenho da ferramenta no texto acima.

27

Propriedades da Ferramenta "Início"

Esta ferramenta indica o início do mapa. Podem existir vários em um processo, desde que representem situações diferentes (por exemplo, um início "normal" e um que depende de uma regra específica).

Suas propriedades são:

28

Bloquear: possibilita o bloqueio da atividade, evitando que ela seja movida (trocada de lugar) por engano, desorganizando o modelo.

Descrição: descrição do que a atividade realiza. Como podem existir vários "inícios" em um mesmo mapa, é interessante descrever cada um deles.

Metadados: permite criar constantes para o processo e/ou atividade. Possibilita uma forma organizada de manter as constantes utilizadas por scripts ou funções.

Mostrar Etiqueta: define se o nome do objeto deve ser exibido no mapa (true) ou não (false).

Nome: nome da atividade. Como podem existir vários "inícios" em um mesmo mapa, o nome deve indicar a situação que esse início identifica. Por exemplo: "início por regra de tempo", "início padrão", etc.

Nome de Instância: define o nome que as instâncias dessa atividade terão quando forem ativadas. Por exemplo, pode-se definir que a instância da atividade “Aprovação de Compra” terá como nome, além de “Aprovação de Compra”, o número sequencial daquela compra, facilitando a localização no meio de outras atividades.

Nome Único: o ÁGILES converte o nome da atividade em um nome sem caracteres especiais (acento, cedilha, etc.) e espaços. Esse nome deve ser "único", ou seja, não pode ter mais de um objeto neste mapa em que esse nome se repita, senão o processo não será validado.

PK: número de identificação do objeto dentro do ÁGILES. É gerado automaticamente quando o processo é salvo ou validado.

Permitir suspensão do processo: informa se o processo poderá ou não ser suspenso pelo ÁGILES (através do console de administração, no módulo “Administração”) quando essa atividade estiver "ativa", ou seja, disponível para ser executada. A suspensão interrompe a execução do processo no ponto em que ele estava.

Re-executar: permite que uma atividade possa ser automaticamente reiniciada pelo ÁGILES, no caso de uma exceção não tratada pelo processo. Este reinício acontece uma vez ao dia.

Exemplo: se o servidor de banco de dados estiver indisponível, impossibilitando a conclusão da atividade no momento (e a mesma suportar qualquer tipo de transação, ou seja, um controle que verifica se a rotina foi completa ou parcialmente executada), ela será reiniciada no começo do próximo dia. Dessa forma evita-se que manutenções em equipamentos ou outros tipos de problemas, acarretem erros na execução do processo.

Referência: tempos de referência. Para alterar essas informações, clique na propriedade e, do lado direito, surgirá um botão com reticências. Ao clicar nas reticências será aberto um quadro para especificação do "Tempo Total" (execução total do processo), "Tempo Humano" (interação humana) e "Tempo de Espera" (tempo ocioso e gasto com processamento), em minutos, horas ou dias.

Sincronizado: se essa propriedade estiver “true”, quando for executada, nada mais será executado, não tendo concorrência no processamento.

Tipo de evento: define o tipo de situação que deve acontecer para que o evento seja executado e, consequentemente, o processo seja iniciado. De acordo com o tipo utilizado, podem existir propriedades específicas, que não foram citadas neste tópico

29

(aqui foram relacionadas às propriedades do tipo "normal", que são comuns a todos eles). Os tipos possíveis são:

Normal: simplesmente inicia o processo. Mensagem: início através de uma mensagem externa (Web Service). Este tipo

de evento é utilizado para que outros programas iniciem um processo no Ágiles.

Regra: o processo será iniciado quando uma condição (regra) se tornar verdadeira. Por exemplo, para um fluxo de trabalho de venda de ações, quando o valor subir 10% em um dia, o processo deve ser iniciado.

Tempo: o processo será inciado segundo uma regra de tempo. Por exemplo: toda segunda-feira, ou no dia 02/01/2014.

Ligação: inicia o processo atual quando outro processo, que esteja "ligado" a ele através desse tipo de evento, tiver sido finalizado. Por exemplo: um processo finalizado com um evento com o nome "1" iniciará outro processo que começa por um evento de mesmo nome.

Sinal: início através de um sinal externo. Este tipo de evento é utilizado para que outros programas iniciem um processo no Ágiles.

ZValue: a folha de desenho possui diversas "camadas". Cada objeto do mapa fica em uma "camada" diferente e o número dela é mostrado nessa propriedade. Esse número indica quais objetos ficarão "por cima" caso se coloque mais de um objeto no mesmo local do mapa. Essa informação não pode ser alterada manualmente, apenas através dos comandos "Enviar para Trás" e "Trazer para frente", disponíveis clicando-se com o botão direito do mouse no objeto desejado.

Obs.: a área cinza, na parte inferior da tela, exibe o conteúdo da propriedade atualmente selecionada.

Propriedades da Ferramenta "Evento"

Esta ferramenta representa eventos intermediários, isto é, ocorrências no processo em andamento; sendo que o evento pode notificar ou ser notificado dessas ocorrências. A regra/condição para que o evento aconteça é especificada no próprio evento. Suas propriedades são:

30


Descrição: descrição do que o evento realiza. Evento: data para início desse evento, e situação em que ele se realizará (por exemplo:

para eventos de "tempo" a situação pode ser um prazo ou uma data específica; para eventos "normais" pode ser uma condição para que ele aconteça). Clicando-se no

31

círculo à esquerda do nome da propriedade, vê-se que a mesma divide-se em "Data de Início" e "Avaliação". Clicando à direita de cada item será aberto um assistente para a definição de seu conteúdo.


Nome da Etiqueta: define se o nome do objeto deve ser exibido no mapa (true) ou não (false).

Nome: nome do evento. Nome de Instância: define o nome que as instâncias dessa atividade terão quando

forem ativadas. Por exemplo, pode-se definir que a instância da atividade “Aprovação de Compra” terá como nome, além de “Aprovação de Compra”, o número sequencial daquela compra, facilitando a localização no meio de outras atividades.

Nome Único: o ÁGILES converte o nome do evento em um nome sem caracteres especiais (acento, cedilha, etc.) e espaços. Esse nome deve ser "único", ou seja, não pode ter mais de um objeto neste mapa em que esse nome se repita, senão o processo não será validado.







Tipo de evento: define o tipo de situação que deve acontecer para que o evento seja executado. De acordo com o tipo utilizado, podem existir propriedades específicas, que não foram citadas neste tópico (aqui foram relacionadas as propriedades do tipo "normal", que são comuns a todos eles).

32

Os eventos podem ser utilizados entre duas atividades (na sequência do fluxo) ou anexados a uma atividade ou sub-processo (eventos de "borda") e, de acordo com o uso, seus tipos e comportamentos são diferentes.

Os tipos possíveis para utilização entre duas atividades são:

Normal: o resultado da avaliação será SEMPRE Verdadeiro ou Falso. Quando "falso", o processo espera o tempo definido em "Data de Início" e volta a executar a "Avaliação" até que a mesma retorne Verdadeiro. Só então o processo executará a próxima atividade.

Exceção: aguarda uma exceção ou informa a ocorrência de uma (exceção é uma ação que não faz parte das operações "normais", por exemplo, um erro pelo não preenchimento de um campo do formulário, ou na tentativa de acesso a um banco de dados).

Mensagem: aguarda uma mensagem (Web Service). Regra: aguarda determinada regra ser contemplada. Tempo: aguarda um determinado tempo para execução. Compensar: inicia um evento que "compensa" uma atividade, a utilização

normal é para desfazer o que a atividade tinha feito. Ligação: evento que une dois pontos distantes de um processo. Por exemplo:

um evento com o nome "1" levará a outro evento de mesmo nome no fluxo. Utilizá-lo é equivalente a colocar uma transição extensa que una os dois pontos do fluxo.

Sinal: aguarda um Sinal

Os tipos de eventos que podem ser anexados a uma atividade ou sub-processo são:

Exceção: aguarda a ocorrência de uma exceção na atividade ou sub-processo a que este evento está anexado.

Mensagem: aguarda uma mensagem (Web Service). Regra: o evento será executado quando uma condição (regra) se tornar

verdadeira. Por exemplo, quando há um documento aguardando aprovação e o mesmo é modificado, a aprovação deverá ser suspensa porque o documento precisará ser revisado novamente. A suspensão acontecerá através do evento do tipo "regra".

Tempo: aguarda um determinado tempo para execução. Esse evento é utilizado para aguardar o decurso de prazo de uma atividade, por exemplo.

33

Cancelar: possibilita o cancelamento de uma atividade ou sub-processo. Se esse evento estiver anexado a uma atividade de usuário, existirá a opção "cancelar" na tela da mesma.

Compensar: mapeia uma regra de compensação (rollback) para a atividade ou sub-processo a que este evento está anexado. Se um evento final de compensação ocorrer, todos os eventos de compensação em atividades já executadas serão iniciados.



Dependendo do tipo, o evento ganha novas propriedades especificas. Se o evento for normal ele terá “Data de inicio” e “Avaliação”.

O evento sendo “Exceção” ele terá “Código do erro”

Sendo o evento do tipo “Mensagem” os atributos serão: Partes de Entrada, Partes de

Saída e Em Mensagem.

34

Se o evento for de “regra”, os tributos serão: Período de verificação e Verificação.

Evento sendo de “tempo” os atributos serão: Data de início, cancelar Atividade e

Reagendar ao cancelar.

E sendo o evento do tipo “Sinal”, os atributos serão: Tipo de Sinal, Receber Sinal,

Propriedades de Recebimento, Ao consumir Sinal e Cancelar Atividade.

35

Propriedades da Ferramenta "Fim"

Esta ferramenta indica o final do processo e podem existir vários no mesmo mapa. Suas propriedades são:

36


Descrição: descrição do que a atividade realiza. Como podem existir vários "finais" em um mesmo mapa, é interessante descrever cada um deles.


37

Mostrar Etiqueta: define se o nome do objeto deve ser exibido no mapa (true) ou não (false).

Nome: nome da atividade. Como pode existir vários "finais" em um mesmo mapa, o nome deve indicar a situação em que esse final aconteceu. Por exemplo: "fim por cancelamento", "término após publicação", etc.









Tipo de evento: define situações específicas que acontecerão no momento em que o processo for finalizado. De acordo com o tipo utilizado, podem existir propriedades específicas, que não foram citadas neste tópico (aqui foram relacionadas as propriedades do tipo "normal", que são comuns a todos eles). Os tipos possíveis são:

38

Normal: finaliza o processo se não existir nenhuma atividade pendente. Exceção: só pode ser utilizado em sub-processos. Finaliza o sub-processo e

informa o processo-pai que uma exceção aconteceu. Mensagem: finaliza o processo e envia uma mensagem (Web Service). Cancelar: finaliza o processo e inicia um evento de cancelamento na borda

desse processo. Compensar: finaliza o processo e inicia os eventos de compensação que

existirem no escopo deste processo, do último para o primeiro. Utilizado em situações de exceção para desfazer as atividades citadas nos respectivos eventos (aquelas que serão "compensadas").

Ligação: finaliza o processo atual e inicia um outro que esteja "ligado" a ele através desse tipo de evento. Por exemplo: um evento com o nome "1" levará a outro processo que inicia por um evento de mesmo nome.

Terminar: finaliza o processo, cancelando qualquer atividade pendente. Sinal: finaliza o processo e envia um Sinal



Propriedades da Ferramenta "Atividade de Usuário"

Esta ferramenta representa uma atividade que exige interação humana.

Ela é composta por pelo menos uma tarefa, mas pode conter diversas, sendo algumas obrigatórias (mandatórias) e outras opcionais. Independente da quantidade de tarefas, a "Atividade de Usuário" deve ser utilizada sempre que a atividade exigir pelo menos uma interação humana.


39

Atividade: características dessa atividade. Clicando-se na seta à esquerda do nome da propriedade, vê-se que a mesma divide-se em:

Responsáveis: usuários responsáveis pela execução da atividade; podem ser pessoas, grupos, nós organizacionais, cadastrados no ÁGILES.

Vencendo: data que identifica que a atividade esta vencendo. (o semáforo da atividade ficará amarelo)

40

Atrasado: data limite para realização dessa atividade. O processo precisa tratar o que acontecerá se ela não for executada até essa data. . (o semáforo da atividade ficará vermelho).

Clicando à direita de cada item será aberto um assistente para a definição de seu conteúdo.

Atividade deve ser bloqueada: quando ativada (true), essa propriedade indica que a atividade deve ser bloqueada para que o usuário possa começar a executá-la. Desta forma, outros usuários do mesmo grupo poderão visualizá-la mas não trabalhar com ela (evitando o conflito de duas pessoas tentarem executar a mesma atividade). Deve ser usada sempre que uma atividade for enviada para um grupo.

Obs.: o bloqueio e liberação da atividade ocorrem através dos botões "Bloquear" e "Liberar" que existem na tela onde a atividade é apresentada (módulo Área de Trabalho).


Descrição: descrição da atividade. Deve explicar, de maneira global, o que esta atividade realiza (pois uma explicação detalhada pode ser colocada em cada tarefa que compõe essa atividade).

Expressões: instruções que devem ser executadas no início e no final da atividade. Clicando-se no círculo à esquerda do nome da propriedade, vê-se que a mesma divide-se em "Expressão Inicial" (uma ação muito comum é o pré-preenchimento de alguns campos do formulário, por exemplo: data, nome do executante) e "Expressão Final" (exemplo: cálculo de alguma informação a partir de um valor preenchido no formulário). Clicando à direita de cada item será aberto um assistente para a definição de seu conteúdo.

Inicialização a Atividade: é possível nessa propriedade determinar várias outras propriedades de uma só vez, como o nome da instancia, o responsável pela atividade, as datas que serão utilizadas no semáforo.


Mostrar tela de atividade: ao clicar em uma atividade para executá-la (no comando Minhas Atividades do módulo Área de Trabalho) pode-se visualizar - ou não - a tela com as informações dessa atividade (que inclui a lista das tarefas que a compõem).

Quando a propriedade "Mostrar tela de atividade" estiver definida como "true", a tela será exibida, quando estiver como "false" ela não aparecerá. Na segunda situação, ao clicar para executar a atividade será diretamente exibido o formulário da primeira tarefa mandatória. Após a conclusão dessa tarefa, se existirem outras na mesma atividade, a tela com informações da atividade será exibida para que o usuário possa realizar as demais tarefas.

41

Nome: nome da atividade. É o nome que aparecerá na lista de atividades para o usuário realizar.



Notificação: permite especificar um e-mail que será enviado aos responsáveis por essa atividade no momento em que a própria atividade for disponibilizada para eles. Clicando-se no círculo à esquerda do nome da propriedade, vê-se que a mesma divide-se em "Assunto" (informação que será exibida no campo "Assunto" do e-mail), "Mensagem de Notificação" (conteúdo do e-mail) e "Tipo do Conteúdo" (define se o texto da mensagem terá formatação - HTML - ou não). Clicando à direita de cada item define-se seu conteúdo (dependendo do item, pode ser aberto um assistente para essa definição, o conteúdo pode ser digitado diretamente ou escolhido em uma caixa de combinação).



Prioridade: permite escolher a prioridade dessa atividade no processo. Essa prioridade pode ser mais uma variável a ser utilizada no decorrer do processo.





42

Tarefas: lista de tarefas que compõem esta atividade (várias tarefas serão necessárias sempre que uma atividade precisar usar formulários diferentes ou interagir de forma diferente com os campos de um mesmo formulário). Ao clicar à direita dessa propriedade será aberta uma tela para a definição de seu conteúdo.

Clique em "Adicionar" para incluir cada tarefa nova.

44

Deve ser escolhido o tipo da tarefa (Formulário HTML ou Formulário de Aplicação Web). E para cada tipo de tarefa existem campos específicos para serem preenchidos e configurados que serão explicados nas sessões seguintes desse documento.

Caso sua execução seja obrigatória para a conclusão da atividade, o item "Mandatório" deve ser selecionado.



Propriedades da Ferramenta "Atividade Automática"

Esta ferramenta representa uma atividade completamente executada pelo sistema. Suas propriedades são:

45

Ação: ação/comando que esta atividade executará. Clicando-se no círculo à esquerda do nome da propriedade, vê-se que a mesma possui um item também chamado "Action". Clicando à direita desse item será aberto um assistente para a definição da ação.


Descrição: descrição do que a atividade realiza.

46


Nome: nome da atividade. Nome de Instância: define o nome que as instâncias dessa atividade terão quando











47

Propriedades da Ferramenta "Notificação"

Esta ferramenta envia uma notificação/mensagem formal (e-mail) para o usuário especificado. Suas propriedades são:

48


Descrição: descrição da atividade (não da mensagem). Metadados: permite criar constantes para o processo e/ou atividade. Possibilita uma

forma organizada de manter as constantes utilizadas por scripts ou funções. Nome: nome da atividade (não da mensagem). Nome de Instância: define o nome que as instâncias dessa atividade terão quando



Notificação: especificação do e-mail. Clicando-se no círculo à esquerda do nome da propriedade, vê-se que a mesma divide-se em "Para" (destinatário do e-mail), "CC" (pessoas que receberão cópia do e-mail), "CCO" (pessoas que receberão uma cópia do e-mail, mas seus nomes não serão exibidos para os demais destinatários), "Tipo de Conteúdo" (define se o texto da mensagem terá formatação - HTML - ou não), "Assunto" e "Mensagem" (respectivamente, assunto e mensagem do e-mail). Clicando à direita de cada item define-se seu conteúdo (dependendo do item, pode ser aberto um assistente para essa definição, o conteúdo pode ser digitado diretamente ou escolhido em uma caixa de combinação).





Referência: tempos de referência. Para alterar essas informações, clique na propriedade e, do lado direito, surgirá um botão com reticências. Ao clicar nas reticências será aberto um quadro para especificação do "Tempo Total" (execução

49

total do processo), "Tempo Humano" (interação humana) e "Tempo de Espera" (tempo ocioso e gasto com processamento), em minutos, horas ou dias.




50

Propriedades da Ferramenta "Sub-Processo"

Estas ferramentas indicam/iniciam um sub-processo. Quando a ferramenta possui o sinal "-" na parte inferior, significa que o sub-processo está expandido, isto é, seu conteúdo é exibido no mapa atual. Quando possui o símbolo "+", significa que seu conteúdo está representado em outro mapa.


51


Descrição: descrição do que o sub-processo realiza. Metadados: permite criar constantes para o processo e/ou atividade. Possibilita uma

forma organizada de manter as constantes utilizadas por scripts ou funções.

52

Nome: nome da atividade (pode ser o nome do sub-processo que ela representa, mas há uma propriedade específica para detalhar esse sub-processo).








Sub Processo: especificação do sub-processo que será executado. Clicando-se no círculo à esquerda do nome da propriedade, vê-se que a mesma se divide como descrito abaixo.

Para sub-processos que NÃO estão expandidos (ferramenta com o "+"): "Sub-Processo" (nome do sub-processo que será executado).

Para sub-processos que estão expandidos (ferramenta com o "-"): "Iniciar ativ" (indica qual evento determinará o início do sub-processo; é fundamental quando o sub-processo possui diversos eventos de início).

Para todos os sub-processos: Multiple Instance: expressão que determina o número de instâncias

paralelas que serão iniciadas. Essa expressão deve retornar uma matriz de índices para serem enviados para os sub-processos.

53

Para recuperar este valor, cada uma das instancias de sub processo receberão um objeto de nome “index” em seu contexto

Exemplo em Jython: processo = variables.getValue('process'); result = processo.getContext().getObject("index");

Expressão Inicial: script/expressão inicial que será executada antes da primeira atividade do sub-processo.

Expressão Final: script/expressão que o sub-processo retorna para o processo principal.

Transação: informa se esse sub-processo é uma transação ou não. Se ele for uma transação e for finalizado por um evento de "exceção" ou "cancelamento", e pelo menos uma de suas atividades possuir um evento de "compensação", a "compensação" será efetuada para todas as atividades da transação (sub-processo).

Clicando à direita de cada item pode-se definir seu conteúdo (normalmente é aberto um assistente para a definição dos mesmos).



Propriedades da Ferramenta "Gateway"

Esta ferramenta representa a divisão ou união de diversos caminhos.

A divisão equivale a uma decisão, ou seja, divide o fluxo em quantos caminhos forem necessários. Apesar de precisar ser representada, esta atividade não contém as condições do desvio, as quais são especificadas na ferramenta "Transição".

A sincronização, propriamente dita, é a união dos caminhos. Ela fica em execução até que todas as atividades que "chegam" nela estejam concluídas e, então, permite que o fluxo "siga adiante".


54


Descrição: descrição do que a atividade realiza. Metadados: permite criar constantes para o processo e/ou atividade. Possibilita uma

forma organizada de manter as constantes utilizadas por scripts ou funções. Mostrar Etiqueta: define se o nome do objeto deve ser exibido no mapa (true) ou não

(false). Nome: nome da atividade. Nome de Instância: define o nome que as instâncias dessa atividade terão quando




55






Tipo do Gateway: define o comportamento dessa atividade. De acordo com o tipo escolhido, podem existir propriedades específicas. Os tipos possíveis são:

Nenhum: representa a "decisão", ou seja, a partir dela o fluxo poderá seguir por diversos "caminhos" diferentes de acordo com a situação.

Xor: apenas um dos "caminhos" é seguido. Os "caminhos" são avaliados e quando o primeiro deles é verdadeiro, ele é seguido.

Ou: mais de um "caminho" pode ser seguido. Similar ao tipo “Nenhum”, porém a documentação fica explícita.

Complexo: é um tipo personalizado de decisão, onde quem está mapeando o processo define qual a condição exata para o fluxo de trabalho continuar. Por exemplo, essa decisão pode ter 5 entradas, mas a próxima atividade só será executada se 3 desses "caminhos" acontecerem. Essa situação só poderá ser resolvida através do tipo "complexo".

Na notação BPMN representa uma decisão (ou sincronização) de um tipo complexo, por exemplo, se 2 em 3 caminhos chegarem, ele segue. Esta regra deve ser evitada, pois oculta regras em seu interior, dificultando a compreensão do comportamento do fluxo.

56

Paralelo: representa a "sincronização", ou seja, a união ou separação de todos os "caminhos" que chegam nesta atividade para, então, o fluxo continuar sua execução.



57

Propriedades da Ferramenta "Pool"

Esta ferramenta identifica "players", ou seja, departamentos/empresas/locais diferentes envolvidos no processo. A "raia" deve envolver todo o fluxo pertencente àquele "player".



Descrição: objetivo dessa raia. Metadados: permite criar constantes para o processo e/ou atividade. Possibilita uma

forma organizada de manter as constantes utilizadas por scripts ou funções. Nome: nome da raia. Nome de Instância: define o nome que as instâncias dessa atividade terão quando

forem ativadas. Por exemplo, pode-se definir que a instância da atividade “Aprovação

58

de Compra” terá como nome, além de “Aprovação de Compra”, o número sequencial daquela compra, facilitando a localização no meio de outras atividades.

Nome Único: o ÁGILES converte o nome da raia em um nome sem caracteres especiais (acento, cedilha, etc.) e espaços. Esse nome deve ser "único", ou seja, não pode ter mais de um objeto neste mapa em que esse nome se repita, senão o processo não será validado.



Pool: define se a orientação da raia é vertical ou horizontal. Clicando-se no círculo à esquerda do nome da propriedade, vê-se o item "Orientação". Clicando à direita dele escolhe-se seu conteúdo.







59

Propriedades da Ferramenta "Anotação"

Esta ferramenta permite a adição de comentários/anotações no mapa. Apesar de possível, é recomendável que existam poucos comentários para não "poluir visualmente" o mapa (lembrando que a maior parte das ferramentas tem, dentro de suas propriedades, campos para especificação do nome e descrição da mesma).

A única propriedade da ferramenta "Anotação" é o texto do comentário, que pode ser definido clicando-se à direita da propriedade "Descrição".


60

Artefato

Artefatos são mecanismos para demonstrar como os dados são requeridos ou produzidos pelas atividades. Estão conectados às atividades através de Associações.

Grupo

Um Grupo é representado por um retângulo com cantos arredondados com linhas tracejadas (veja à direita). O agrupamento pode ser utilizado para fins de documentação ou de análise, mas não afeta o Fluxo de Sequência.

62

MGP – Metodologia em gestão de projetos de BPM

Técnicas de levantamento/analise

Para as reuniões de levantamento e analise dos processos, primeiramente, é

necessário ter um espaço para acomodar confortavelmente todos os participantes. É

importante ter uma lousa e/ou um flip chart para ajudar nas explicações. Se possível um

datashow ou uma TV/monitor.

Nas reuniões é importantíssima a presença de um representante de cada setor que

será afetado com a implantação do novo processo, desde a direção até o usuário final, aquele

que irá utilizar o processo no dia-a-dia.

É necessário levar para essas reuniões os formulários, documentos, gráficos,..., que já

são utilizados no dia-a-dia, pois eles serão insumos no levantamento do processo.

Um dos presentes deve ser o mediador da reunião. Ele será responsável em alinhar as

expectativas com os demais participantes e incentivar a participação de todos. E quando

necessário solicitar silencio para que a reunião prossiga da forma mais tranquila e focada

possível.

Se por algum motivo a discussão saiu do foco principal da reunião, o mediador deve

suspender o assunto desviado e retornar para o foco da reunião.

Primeiramente é necessário fazer o alinhamento expectativa do processo. O objetivo

primeiramente é levantar o processo, mas ainda sem se preocupar em detalhar as atividades.

Para isso utiliza-se reunião de brainstorming, entrevistas, questionários, análise de

documentação existente, análise de sistemas legados e coleta de evidências.

Dependendo do processo essa etapa necessitará a realização de varias reuniões, pois o

processo tem que estar claro para todos os envolvidos.

Terminado essa fase, agora é hora de levantar as atividades. Para isso é necessário

fazer protótipo dos formulários, descrevendo detalhadamente o funcionamento de todas as

atividades.

O cuidado com esse detalhamento é importantíssimo, pois esse será a base para toda

implementação do sistema e será utilizado como base para a fase de teste.

Documentação padronizada

63

Para o desenvolvimento de um processo, é importante que todos os seus detalhes

estejam definidos e em documentos padronizados. Isso será útil tanto na documentação do

processo quanto para o desenvolvedor que receberá o documento para a implementação.

O desenvolvedor deve receber um documento com essas descrições. Podem existir

vários modelos de documento, cada empresa pode definir seu modelo. Porem por padrão

utilizamos um documento chamado “IN03”.

Nesse documento têm que haver a explicação do objetivo do processo, o desenho do

fluxo, as atividades e suas tarefas, os grupos e os formulários com os seus campos e botões.

Para cada campo do formulário deve-se especificar o nome do campo, se é obrigatório

o preenchimento, o tipo de informação, a descrição e o tamanho do campo.

Se o processo utilizar OT, também será necessário descrever todos os seus atributos.

O documento “MODELO IN03” que esta no “Anexo A” deste documento, descreve a

estrutura desse documento explicando seu preenchimento.

Exercício

Com base da requisição abaixo, desenhar o fluxo desse processo. E em seguida fazer

sua automação.

Em uma empresa, para melhorar a qualificação dos funcionários, necessita de um

processo para facilitar a solicitação de cursos por partes dos funcionários.

Quando um funcionário pretende fazer um curso, ele deve iniciar um processo de

solicitação. Esta deve ser aprovada pelo RH e posteriormente pela diretoria Executiva da

empresa.

Caso seja reprovada a solicitação, o solicitante deve receber um e-mail justificando a

recusa. E caso aprovado além do envio do e-mail para o solicitante, deve ser publicado a

autorização.

O RH deve analisar se há o “Saldo de Capacitação” suficiente e também a demanda de

capacitação dos colaboradores.

As informações necessárias para o funcionário fazer uma requisição de curso são:

Nome do funcionário;

Tipo de capacitação (Doutorado, mestrado, Pós-graduação, Especialização, Extensão e

outros);

Instituição;

64

Nome da capacitação;

Cidade;

Estado;

Site da instituição;

Valor do curso;

Data de realização;

Duração.

65

Melhoria contínua de processo

Se em um processo tiver comportamentos que se repetem, é possível desenhar um

fluxo genérico. O exemplo abaixo é de um processo de licitação. Na regra de negocio desse

processo requer três fases: registro de preço, proposta técnica e habilitação.

As três fases tem que ser executadas, mas a ordem que será executada vai depender

da escolha do juiz no momento que o processo já estiver executando.

Mesmo que cada fase trate de um assunto, o fluxo que elas devem seguir é igual, com

isso é possível simplificar o processo, fazendo atividades genéricas. Isso agilizará o

desenvolvimento e dará mais flexibilidade ao processo.

No fluxo abaixo a atividade “Abertura de Licitação” é genérica, possui um formulário

que atende as 3 fases e será utilizada nas três fases do processo.

67

HTML Form

Estrutura

HtmlForms são formulários persistidos, publicados e geridos integralmente pelo Ágiles.

Para criar um HtmlForm deve ser obedecido a seguinte estrutura:

Criar um arquivo .zip com todos os arquivos do formulário (html, css, js, imagens, etc...)

O formulário deve se chamar form.html e ficar na raiz do arquivo zip.

Ir ao módulo Form Repository e adicionar o zip

Exemplo:

<html> <body> <form name=“htmlform” method=“post”> <input type=“text” name=“campo1”> <input type=“text” name=“campo2”> <input type=“button” name=“save” value=“Salvar” onClick=“doSave()”> <input type=“button” name=“concl” value=“Concluir” onClick=“doConclude()”> </form> </body> </html>

Como criar Arrays em HtmlForms Arrays são listas ou blocos que podem ser repetidos diversas vezes no intuito de

armazenar diversas linhas de um mesmo campo, um exemplo seria um campo de “Outras

áreas”, onde seria possível adicionar diversas áreas em um formulário.

Para criar essa estrutura devem ser obedecidas as seguintes regras:

Marcar o ponto do formulário onde o Array será repetido com um div vazio cujo Id termine com “_array”. (<div id="parent_array">).

Ter um div fora do bloco de body que o campo ID termine com “_array_count” (<div

id="child_array_count" style="visibility:hidden; position:absolute; top:0">).

Pode ser adicionado ao div (opcionalmente) um botão para remover uma linha do array (<input type="button" name="BTN_REMOVE_ARRAY" value="Remover"

onclick="AGILES_removeArray('child_array_count')">). Pode ser adicionado ao formulário (opcionalmente) um botão que adicione

linhas/blocos do array (<input type="button" name="BTN_ADD_ARRAY" value="Adicionar" onclick=’

AGILES_addArray("child_array_count", "parent_array");’>).

68

No onload do formulário, o array deve ser registrado ( //Registro do array no formulário. AGILES_registerArray("child_array_count", "parent_array"); //chamada ao método criado em Run-Time pelo Ágiles para carregamento dos arrays. loadArrays(); //Após o carregamento dos arrays, na chamada acima, o método AGILES_mountAll() //monta os arrays fazendo as chamadas necessárias aos metodos addArray. AGILES_mountAll(); ).

Exemplo:

<script language="javascript" src="./js/agiles_arrays.js"></script> <html> <body onload="onLoadScript()"> <form name="htmlform" method="post"> Exemplo demonstrando array no Ágiles usando DIV (padrão). <table width="100%"> <tr> <td width="200"><b>Nome</b> </td> <td width="200"><b>Endereço</b></td> <td width="200"><b>Email</b> </td> <td><b>Action</b></td> </tr> </table> <div id="parent_array">  </div> <input type="button" name="BTN_ADD_ARRAY" value="Adicionar" onclick="addLine()"><br> <input type="button" name="save" value="Save" onclick="doSave()"><br> <input type="button" name="conclude" value="Conclude" onclick="doConclude()"> </form> </body> <div id="child_array_count" style="visibility:hidden; position:absolute; top:0">  <table width=100%> <tr> <td width="200"> <input type="text" name="NOME_ARRAY" style='width: 100%'> </td> <td width="200"> <input type="text" name="ENDERECO_ARRAY" style='width: 100%'> </td> <td width="200"> <input type="text" name="EMAIL_ARRAY" style='width: 100%'> </td> <td> <input type="button" name="BTN_REMOVE_ARRAY" value="Remover" onclick="AGILES_removeArray('child_array_count')"> </td> </tr> </table> </div> </html>  <script language="javascript"> function addLine() { AGILES_addArray("child_array_count", "parent_array"); } function onLoadScript() {

69

//Registro do array no formulário. AGILES_registerArray("child_array_count", "parent_array"); //chamada ao método criado em Run-Time pelo Ágiles para carregamento dos arrays. loadArrays(); //Após o carregamento dos arrays, na chamada acima, o método AGILES_mountAll() //monta os arrays fazendo as chamadas necessárias aos metodos addArray. AGILES_mountAll(); } </script>

Choose O Ágiles disponibiliza algumas ferramentas facilitadoras de seleção, são chamados de

choose e vinculados aos formulários (HtmlForms e WebForms) em forma de função que abre

um popUp relativo a seleção a ser realizada

70

Para utilizar um choose em seu formulário, no instante do load do HTML (tag dentro

do Body) você deve registrar o comportamento do choose através da função

attachChooseEvent.

attachChooseEvent(1, 2, 3, 4, 5, 6); 1. Objeto do botão que disparará o choose. 2. Objeto do campo do formulário que receberá o valor do atributo NAME do

objeto selecionado. 3. Objeto do campo do formulário que receberá o valor do atributo ID do objeto

selecionado. 4. Contexto do Ágiles, normalmente ‘/agiles’. 5. Nome do tipo do choose a ser utilizado. 6. Parâmetro a ser informado ao choose.

Exemplo:

function onLoad() { var form = document.htmlform; attachChooseEvent( form.BOTÃO, form.CAMPO_NOME, form.CAMPO_PK, '/agiles', 'container/chooseContainer', '32-1'); // ID da pasta raiz da estrutura do visitor. };

Tipos de choose disponibilizados: user/chooseUsers -> Seleção de usuários.

container/chooseContainer -> Seleção de sub pastas de um container (somente

containers)

container/chooseContainerWithChildren -> Seleção de items em um Container (por

exemplo, arquivos em uma pasta, usuários em um grupo)

visitor/chooseVisitorFolderWithChildren -> Seleção de itens publicados no visitor

Anexar arquivos

No Ágiles é possível anexar um arquivo ao seu formulário/processo de forma muito

simples utilizando um attachFileEvent

71

Para utilizar um attachFileEvent em seu formulário, no instante do load do HTML (tag

dentro do Body) você deve registrar o comportamento do FileEvent através da função

attachFileEvent.

attachFileEvent (1, 2, 3, 4, 5, 6); 1. Objeto do botão que disparará o fileEvent. 2. Objeto do campo do formulário que receberá o valor do atributo NAME do

arquivo recebido. 3. Objeto do campo do formulário que receberá o valor do atributo ID referente

ao arquivo recebido. 4. Contexto do Ágiles, normalmente ‘/agiles’. 5. 'dm/prepareAttachFile' // Nome do Event a ser utilizado. 6. Pk do Folder onde o arquivo será vinculado, caso não informado, o Ágiles irá

importar o arquivo sem vinculá-lo a nenhuma pasta. Exemplo: var form = document.htmlform; attachFileEvent(form. BUTTON_FILE,

72

form.DOCUMENTO_NOME, form.DOCUMENTO_PK, '/agiles', 'dm/prepareAttachFile', form.DS_ATTACHMENT_PK.value // PK do folder onde colocar o arquivo. );

Variáveis de processo Toda instancia de processo possui um objeto chamado Variables que contem os

principais dados relativos ao processo, sempre que vinculado a um processo o Ágiles irá

disponibilizar este objeto para o desenvolvedor.

process -> Instância do processo atual.

initiator -> Usuário que iniciou o processo.

now -> Data atual do servidor.

form(NOME FORM) -> Formulário do processo (somente em caso de HtmlForm).

form(NOME FORM).NOME_CAMPO -> Campo do formulário (somente em caso de

HtmlForm).

currentActivity -> Atividade atual no momento de execução.

initiator.name -> É possível acessar propriedades dos objetos, como o nome do

usuário

process.parentProcess.startDate -> Da mesma forma é possível acessar as

propriedades dos processos e seus objetos relacionados (vide diagramas de classes).

73

Metadados Metadados são informações que ficam contidas vinculadas a qualquer Item do

sistema, como por exemplo, o CPF que não faz parte do User do Ágiles, pode ser naturalmente

vinculado como sendo um Metadado deste objeto.

Definindo Metadados Estes comandos irão atribuir um valor ao metadado CPF em uma instancia de User,

porem ele pode ser utilizado para qualquer Item do Agiles, com qualquer nome de metadado.

Em Java:

initiator.getMetaData().setMetaData("CPF", "123.456.789-44);

Em Jython:

variables.getValue(“initiator”).metaData.setMetaData(‘CPF’,’123.456.789-44’)

Buscando Metadados O metadado fica vinculado ao objeto, assim sendo, basta buscar o container de

metadado e então buscar o atributo definido.

Em Java:

String valor = initiator.getMetaData().getMetaData("CPF");

Em Jython:

valor = variables.getValue(“initiator”).metaData.metaData(‘CPF’)

Listando Metadados de um Item Foi disponibilizado no Ágiles uma Action gerencial que lista os atributos e seus valores

Para tanto em seu browser acesse o endereço:

/agiles/item/showItemMetaData.do?id=x-y

Onde x é o ItemType e y é o ItemPK do Item que deseja listar os metadados

74

Visitor O visitor é a estrutura principal que apresenta os dados publicados aos usuários.

Publicação Para realizar uma publicação de um Item qualquer, basta em seu processo utilizar o

comando Util.publishSingle(aonde,oque). O exemplo a seguir cria um objectType a partir de

um template e o publica em uma arvore “Image/Edgard/uma data variável”

template = ObjectTypeFunctions.findTemplateByName('imespSolicitacao') otDocumento = template.createNewInstance() empresa = ‘Image’ solicitante = ‘Edgard’ dataGuia = form.getValue('CA_DATA_PROCESSO').getValue().replace('/','.') folderName = Util.createVisitorFolders("%s/%s/%s"%(empresa,solicitante,dataGuia), "32-1"); folder = Util.getItem(folderName); Util.publishSingle(folder, otDocumento);

75

Jython para Ágiles

Jython é uma implementação da linguagem de alto nível, dinâmica e orientada a

objetos - Python, integrada com a plataforma Java. É certificado como 100% Pure Java e está

especialmente adaptado para as seguintes tarefas:

- "Scripting" Interativo - Programadores Java podem adicionar bibliotecas Jython ao

seu sistema e permitir que usuários finais escrevam scripts simples ou complexos que

adicionem funcionalidades à aplicação.

- Experimentação Interativa - Jython fornece um interpretador interativo que pode ser

usado para interagir com pacotes Java (packages) ou com aplicações Java em

execução. Isto permite aos programadores experimentar e depurar qualquer sistema

Java usando Jython.

- Desenvolvimento Rápido de Aplicações (RAD) - Programas em Python são

tipicamente de 2 a 10 vezes menores que o seu equivalente em Java. Isto se traduz

diretamente para o aumento da produtividade do programador. A integração entre

Python e Java permite aos desenvolvedores misturar livremente as duas linguagens

durante o desenvolvimento e distribuição das aplicações.

Tem como pontos negativos:

- Falta de facilitadores durante a programação – Ainda não há uma forma de “auto-

completar” um comando Jython dentro do seu editor

- Falta de ferramenta para debugar o código Jython durante sua execução.

- Linguagem especifica – Jython não é amplamente utilizado no mercado brasileiro,

isso dificulta encontrar profissionais qualificados para sua manutenção.

No Ágiles é normalmente utilizado para realização de tarefas automáticas simples,

chamada de funções do ContextObject ou da biblioteca de funções do Ágiles.

76

Comparação Java/Jython Ao longo deste item iremos apresentar as formar mais comuns de utilização de Jython

e algumas estruturas utilizadas dentro do Ágiles.

Operadores Lógicos / Aritméticos

Blocos de Controle

Declarações

Métodos de String

Listas

Dicionários

Exemplos

Operadores Lógicos / Aritméticos

Java Jython

&& and

|| or

! not

== Is

equals() ==

obj instanceof class isInstance(obj,class)

+ - = * / % + - = * / %

++ -- Não existem

Math.pow(x,y) x ** y

77

Blocos de Controle

Java Jython

for (int i = 0; i < x; i++) { … }

for i in range(x): #algo

for(Iterator it = col.iterator();it.hasNext(); it.next()) { … }

for obj in col: #algo

if (x) { … } else if (y) { … } else { … }

if condição: … elif condição: … else: …

while(x){ ... }

while x: …

throw exception raise exception

try { ... } finally { ... }

try : … finally : …

try (x) { ... } catch (exception) { ... } finally { ... }

try: … except y: … else: …

Declarações

Java Jython

public void metodo(args) { … }

def metodo(args): …

Person obj = new Person() obj = Person()

import java.util.Collection from java.util import Collection;

78

Métodos de String

Java Jython

obj.toString() str(obj)

s.charAt(i) s[i]

s.compareTo(s2) cmp(s,s2)

s + s2 s + s2

s.indexOf(s2) s.find(s2)

s.lastIndexOf(s2) s.rfind(s2)

s.lenght() len(s)

s.replace(x, y) s.replace(x,y)

s.toLowerCase() s.lower()

s.toUppercase() s.upper()

s.trim() s.strip()

Listas

Java Jython

l = new ArrayList() l = []

l.add(o) l.append(o)

l.addAll(l2) l.extend(l2)

l.clear() del l[:]

l.contains(o) o in l

l.get(i) l[i]

l.indexOf(o) l.index(o)

l.remove(obj) l.remove(obj)

l.remove(i) del l[i]

l.set(i,o) l[i] = o

l.size() len(l)

79

Dicionários

Java Jython

m = new HashMap() m = {}

m.clear() m.clear()

m.containsKey(o) o in m

m.containsValue(o) o in m.values()

m.entrySet() m.items()

m.get(key) m[key]

m.keySet() m.keys()

m.put(key, value) m[key] = value

m.remove(key) del m[key]

m.values() m.values()

l.size() len(l)

Exemplos

Java Jython

int[] x = {1,2,3,4,5,6}; for (int i = 0; i < x.length; i++) { Sytem.out.println(x[i]) }

x = [1,2,3,4,5,6] for a in x: print(a)

if (i > 10 && j < 15) { x = i + j; } else if (i < 10) { x = i – 2 * j; } else { x = 0; } Sytem.out.println(x);

if i > 10 and j < 15: x = i + j elif i < 10: x = i – 2 * j else: x = 0 print(x)

Integração Java/Jython

Para integração da APIs do Java com Jython é necessário importá-las (mesmo java.lang)

from java.util import TreeSet; set = TreeSet() set.add(“um”) set.add(“dois”) print(set.toString())

80

Integração com Ágiles Uso de variáveis do processo

Chamada a Functions

Disparo de subprocessos

Uso de variáveis do processo

Todas as variáveis dos processos estão disponíveis em Jython. processo = variables.getValue(“process”) formulário = variables.getValue(“form(NOME FORM)”) campo = variables.getValue(“form(NOME FORM).NOME_CAMPO”) initiator = variables.getValue(“initiator”)

Chamada de Functions

Todas as Functions Libraries se encontram disponíveis em Jython Form.assign(form, “NOME_CAMPO”, “Valor”) folder = Util.createVisitorFolders(“32-1”, “Teste/pasta”)

Disparando sub processos

Utilizado para disparar múltiplos subprocessos a partir de um processo Exemplos:

Processo de Compras que dispara 1 sub-processo para aprovação de cada item da compra

Processo de auditoria que dispara uma aprovação para cada não conformidade encontrada

Exemplo de subprocessos

from java.util import HashMap; from br.com.imagetec.process import ProcessHelper; descr = variables.getValue(“form(NC).NC_DESCR_ARRAY”) numeros = variables.getValue(“form(NC).NC_NUM_ARRAY”) prop = PropertiesFunctions.getProperties(‘arquivo.properties’) pkProcesso = prop.getProperty(“processo.NC”) pksSubs = “” pk = initiator.PK.toString() initiator = variables.getValue(“initiator”) pkPai = variables.getValue(“process”).PK.toString() for i in range(len(numeros)): nome = “Tratamento da NC:” + numeros[i] + “ - ” + descr[i] params = HashMap() params[‘numeroNC’] = numeros[i] params[‘descrNC’] = descr[i] params[‘parent’] = pkPai processo = ProcessHelper.createnewInstance(pkProc, nome, “”, pk, params) pksSubs = pksSubs + ‘;’ + processo.PK.toString() processo.start() variables.getValue(“process.metaData”).setMetaData(‘pksSubs’,pksSubs)

81

Como fazer a manutenção dos processos desenvolvidos

Atualmente não utilizamos mais a tecnologia de HtmlForms no desenvolvimento dos

novos processos, pois já existem novas tecnologias que apresentam melhores desempenhos.

(Essas novas tecnologias serão abordadas nos próximos capítulos desse manual).

Porem ainda existe muitos processos que foram desenvolvidos com HTML e que

eventualmente precisam sofrer alguma manutenção.

Se for necessário fazer manutenção em algum formulário do tipo: adicionar ou

remover algum campo, modificar cores,... Deve-se primeiro localizar o formulário.

Para isso, estando com formulário aberto dentro do Ágiles, deve-se clicar com o botão

direito em cima do formulário. E depois clicar em “Propriedades”

82

Será exibido todo o endereço do formulário, onde deve anotar o numero da pk, que

seria 43-X. Na imagem abaixo essa pk esta destacada.

Se estiver utilizando o Chrome, deve-se clicar com o botão direito no formulário e

depois clicar na opção “Exibir código fonte do frame”.

83

Abrirá uma nova aba, onde contém todo o endereço do formulário, a pk seria algo do tipo 43-

X, como destacado na imagem abaixo.

84

Se estiver utilizando o FireFox, deve-se clicar com o botão direito no formulário, depois

em “Este frame” e em seguida em “Propriedade do frame”

85

Abrira uma tela que contem o endereço do formulário, nele consta a pk do formulário,

seria algo do tipo 43-X.

86

Tendo a pk do formulário, deve-se abrir o diretório de formulários do Ágiles e localizar

a pasta referente à pk. Como mostrado na imagem abaixo:

87

Dentro dessa pasta contem todos os arquivos do formulário. Estes são os arquivos

temporários, é possível edita-los e já ver o resultado na tela (atualizando o formulário).

88

É possível edita-los

89

Essas mudanças serão feitas no temporário e para salva-las definitivamente será

necessário exportar o processo com os temporários. Para isso deve-se clicar no processo e

após abrir um menu, clica no botão “Exportar com Temporário”

Confirma a exportação

90

Em seguida salva o arquivo do processo no computador.

E depois é necessário importar novamente o processo. Para isso deve-se clicar em

cima do processo, e depois escolher a opção “Importar”.

Em seguida, clicar no botão “Procurar”.

E localizar o arquivo do processo.

91

E depois clicar no botão “Salvar”, destacado na imagem a seguir.

Quando for adicionado um campo novo no formulário, será necessário exportar e

importar o formulário para que o Ágiles reconheça o novo campo.

Depois se deve abrir o desenho de processo. E nas propriedades da atividade de

usuário deve clicar em “Tarefas”

92

Clicar na tarefa e depois em “Editar”

93

Na próxima tela estarão relacionados todos os campos do formulário. Par cada campo

deve definir se ele vai ser visível no formulário, se será “Somente leitura”, ou seja, se poderá

editar a informação do campo.

E também se é um campo “requerido”, ou seja, se é obrigatório o preenchimento

desse campo no formulário.

94

Também á a opção de definir a tarefa como “Mandatório”, ou seja, essa atividade

precisa ser realizada para o fluxo seguir.

95

WEB Form

Configuração do ambiente

Maven

Para o correto funcionamento do projeto é preciso de um arquivo settings.xml no

seguinte caminho %pasta_do_usuario%/.m2/settings.xml. Neste arquivo deve conter todas as

configurações de mirror e profiles, conforme abaixo, modificando os diretórios conforme

necessário.

<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0

http://maven.apache.org/xsd/settings-1.0.0.xsd">

<mirrors>

<mirror>

<id>archiva.default</id>

<url>http://archiva.imagetec.com.br/archiva/repository/internal</url>

<mirrorOf>*,!snapshots</mirrorOf>

</mirror>

<mirror>

<id>archiva.snapshots</id>

<url>http://archiva.imagetec.com.br/archiva/repository/snapshots</url>

<mirrorOf>snapshots</mirrorOf>

</mirror>

</mirrors>

<profiles>

<profile>

<id>snapshot-repo</id>

<activation>

96

<activeByDefault>true</activeByDefault>

</activation>

<repositories>

<repository>

<id>snapshots</id>

<url>http://archiva.imagetec.com.br/archiva/repository/snapshots</url>

<snapshots>

<enabled>true</enabled>

<updatePolicy>daily</updatePolicy>

<checksumPolicy>fail</checksumPolicy>

</snapshots>

<releases>

<enabled>false</enabled>

<checksumPolicy>fail</checksumPolicy>

</releases>

</repository>

</repositories>

</profile>

<profile>

<id>propriedades</id>

<activation>

<activeByDefault>true</activeByDefault>

</activation>

<properties>

<treinamento.agiles.lib>C:\Development\agiles-configs\agiles-

clean\functions\lib</treinamento.agiles.lib>

</properties>

</profile>

</profiles>

</settings>

97

Outro detalhe importante é que todas as bibliotecas (jars) devem ser adicionados na

forma de dependências do maven, no arquivo pom.xml do projeto, pois quem gerencia as

bibliotecas deve ser o Maven. Isso evita que o projeto fique com arquivos desnecessários junto

do código e também facilita o build em outras máquinas.

Projeto

O projeto básico para a criação do projeto utilizando WebForms é composto pelos

seguintes módulos: functions, model, service e view. Eles são utilizados para organizar o

código e definir a forma de geração dos arquivos .jar ou .war e a função de cada um está

descrita na tabela abaixo.

Módulo Função

functions Conter as interfaces para comunicação com o Ágiles.

model Conter as classes de modelo do sistema, como beans e enums.

service Conter as classes com a regra de negócio do sistema.

view Conter as classes e páginas que irão compor a camada de visualização.

Functions

Durante a execução dos processos, há diversos pontos em que o Ágiles precisa realizar

a execução de uma tarefa através da integração com o projeto. Este módulo contém as

interfaces das Functions que serão expostas como WebServices para o Ágiles, para realizar

esta integração. Cada processo do projeto deve ter uma interface de Functions

correspondente, cujo nome contém o nome do processo e o sufixo Functions, segundo

a convenção de nomenclatura.

Exemplo:

Processo Functions

Funções de Demanda br.com.imagetec.treinamento. functions.DemandaFunctions

Model

Módulo que contém as classes com definição das entidades que serão persistidas no

banco de dados. As entidades e atributos são marcadas com anotações JPA nas classes que

representam as entidades. A configuração dos dados de acesso ao banco de dados são

realizadas na classe br.com.imagetec.treinamento.config.TreinamentoBeanConfig.

98

JPA vs Hibernate

A estrutura dos projetos utiliza o JPA como “modelo” para o Hibernate, com o objetivo

de manter a compatibilidade dos mesmos com a especificação e permitir a troca do Hibernate

por outra implementação caso seja necessário. Em contrapartida, esta abordagem impede a

utilização direta de diversos recursos do Hibernate.

Gerenciamento automático de transações

Deve ser utilizada a anotação @Transactional para cada método. Isso permite que o

container consiga gerenciar as transações de acordo com os métodos anotados, facilitando a

vida do desenvolvedor. Se ocorrer algum erro durante o processamento, é feito o rollback da

transação. Caso contrário, o commit é realizado automaticamente.

Referências a processos do Ágiles

Visto que nenhuma informação do projeto é associada aos processos no banco de

dados do Ágiles, é necessário armazenar a chave do processo no banco de dados externo do

projeto e associá-la às entidades que descrevem as regras de negócio no projeto.

Links

Boas práticas no desenvolvimento de sistemas com JPA e Hibernate

http://blog.caelum.com.br/2008/01/28/os-7-habitos-dos-desenvolvedores-hibernate-e-jpa-

altamente-eficazes/

Service

O módulo service deve conter toda a regra de negócios da aplicação, e deve ser

organizada em pacotes de acordo com os conjuntos de atividades semelhantes. As classes de

serviço devem ser anotadas com a anotação @Service.

Módulo que contém as classes com a lógica de negócio do projeto: Controllers,

Finders, Action Controllers e Functions. Estas classes formam os componentes que são

utilizados pelos módulos view e functions para acessar fontes de dados externas (banco de

dados, sistemas legados etc).

Service

Componente que encapsula lógica de negócio e código de interação com bancos de dados (ou outras fontes de dados). Não há uma regra geral de quando deve ser criado um Service. Uma boa motivação para separação de código em um Service é criar métodos que podem ser reutilizados em diversos pontos do projeto. Em alguns casos, é válido criar Services específicos para entidades cuja manipulação é muito frequente no projeto. Um Service pode

http://blog.caelum.com.br/2008/01/28/os-7-habitos-dos-desenvolvedores-hibernate-e-jpa-altamente-eficazes/

http://blog.caelum.com.br/2008/01/28/os-7-habitos-dos-desenvolvedores-hibernate-e-jpa-altamente-eficazes/

99

invocar métodos de outro Service ou Function. O nome da classe deve terminar com o sufixo Service, de acordo com a convenção de nomenclatura.

Functions

Componente contendo a implementação de uma interface de Functions. Na prática, a classe com esta implementação é um Service comum. Seu nome deve conter o mesmo nome da interface implementada, acrescentando-se o sufixo Impl, segundo a convenção de nomenclatura.

Exemplo:

Functions Functions Implementation

(...).treinamento.functions.DemandaFunctions (...).treinamento. functions.impl.DemandaFunctionsImpl

View

Módulo que contém as classes e demais arquivos responsáveis pela interface web. O framework web utilizado é o VRaptor e as páginas são renderizadas utilizando JSP, TagFiles e JavaScript + JQuery.

VRaptor

O VRaptor é um framework para desenvolvimento web muito simples de se utilizar, seguem alguns detalhes sobre ele:

- Qualquer classe pode ser utilizada como controller, desde que seja anotada com a anotação @Resource e o retorno dos métodos é void, para retornar informações para a jsp é utilizado o comando result.include(“nome”, valor).

- Os controllers são desacoplados da especificação de Servlets, facilitando a criação de testes unitários.

- Suporte a injeção de dependências. - Conventions plugin. O conventions plugin permite utilizar o VRaptor sem ter que configurar urls específicas

para cada método dos controllers. A associação entre os resources é feita por meio de convenção de nomenclatura entre a url, o nome da classe da Action e o nome das JSPs relacionadas.

Exemplos de associação:

URL Classe da Action Método JSP

.../usuarios/login (...).usuarios.LoginController login WEB-INF/jsp/usuarios/login.jsp

.../organizardemanda/exibir (...).demanda.OrganizarDemandaController exibir WEB-INF/jsp/organizardemanda/exibir.jsp

http://struts.apache.org/2.x/index.html

https://cwiki.apache.org/confluence/display/WW/Convention%20Plugin

100

URL Classe da Action Método JSP

.../aprovardemanda/exibir (...).demanda.AprovarDemandaController exibir WEB-INF/jsp/aprovardemanda/exibir.jsp

.../aprovardemanda/aprovar (...).demanda.AprovarDemandaController aprovar WEB-INF/jsp/aprovardemanda/aprovar.jsp

A classe do Controller deverá herdar da

classe br.com.imagetec.treinamento.controller.BaseController, pois ela possui algumas abstrações para facilitar o desenvolvimento dos controllers.

TagFiles

As TagFiles possibilitam reutilizar conteúdo em JSPs de forma flexível sem a necessidade de criar código Java. Uma TagFile é uma JSP comum com algumas tags adicionais e pode ser utilizada tanto para a criação de componentes quanto para utilização de templates na definição das páginas do projeto.

Foi definido um template para utilização nos projetos que contém a estrutura básica de layout da página. Este template também faz automaticamente a importação dos arquivos CSS e JS comum a todas as páginas do projeto. É recomendado manter uma separação completa dos códigos HTML, CSS e JS.

Exemplo de utilização do template:

<%@ taglib prefix="template" tagdir="/WEB-INF/tags/template" %>

<template:page name="cadastro-municipios" title="Cadastro de Municípios">

...

</template:page>

Está disponível para uso nos projetos uma biblioteca de TagFiles cuja finalidade é padronizar o layout das páginas e facilitar a criação de telas:

JavaScript + JQuery

O JQuery foi escolhido como biblioteca padrão por simplificar o desenvolvimento de telas e também por motivar a criação de componentes e a consequente reutilização de código.

Separação do HTML e JavaScript

Para ajudar na separação de camadas de conteúdo e scripts, cada página é definida com um objeto representando todas as operações da página. Desta forma, nenhum código JavaScript (nem mesmo a chamada) é inserido no código HTML. Todos os bindings de eventos aos campos da página são feitos através de JavaScript. Isto torna mais fácil depurar e dar manutenção no código.

http://docs.jquery.com/Main_Page

101

Layout com blocos

O layout dos formulários é definido com base em 12 blocos de tamanho igual por linha. Desta forma, os campos podem ocupar um espaço entre 1 e 12 blocos e são jogados automaticamente para a próxima linha. A motivação da utilização deste layout é tornar mais rápido o desenvolvimento de formulários, facilitar o trabalho em conjunto com o designer gráfico do projeto e também permitir que ele seja reajustado de melhor maneira independente da resolução e tamanho da tela do usuário.

Integração com o Ágiles

A integração do Ágiles com o módulo view do projeto ocorre em dois pontos distintos: quando um usuário acessa um módulo externo ou uma atividade de usuário.

É preciso utilizar também as anotações @SaveAgilesTask, @ConcludeAgilesTask e @RunInAgiles nos métodos do controller que executam determinadas atividades relacionadas ao Ágiles. A funcionalidade delas é

Módulo Externo

Um módulo externo é um link configurável que fica disponível no menu lateral do Ágiles para acessar uma URL externa ao Ágiles. Para criar um módulo externo dentro do projeto, basta criar um controller com os métodos necessários. O módulo externo deve ser configurado no Ágiles para enviar chave de autenticação para que o interceptor de autenticação associado aos controllers de módulos externos consiga realizar a autenticação no Ágiles. O nome deve ser definido de acordo com as regras de nomenclatura.

Atividade de Usuário

Uma atividade de usuário no Ágiles é um ponto em um processo em que é necessária a interação com algum usuário do sistema para dar prosseguimento ao processo. Para criar uma atividade de usuário, basta criar controller com os métodos necessários. A atividade de usuário deve ser configurada no Process Designer para enviar chave de autenticação para que o interceptor de autenticação associado às Actions de atividades de usuário consiga realizar a autenticação no Ágiles. O nome deve ser definido de acordo com as regras de nomenclatura.

Injeção de Dependências

A injeção de dependências é um design pattern utilizado para diminuir o acoplamento entre classes. Ela consiste em evitar que uma classe tenha de conhecer como instanciar as outras das quais ela depende. O funcionamento da injeção de dependências é bem simples, as classes que estão anotadas como @Resource, @Service ou @Component podem ser injetadas apenas utilizando a anotação @Inject nas variáveis de classe. Feito isso, quando a classe em questão for instanciada as variáveis de classe dela que possuírem a anotação @Inject serão preenchidas com objetos já instanciados.

Exemplo:

@Service

public class DemandaService {

https://imagetec.jira.com/wiki/pages/viewpage.action?pageId=3408327

102

...

}

public class OrganizacaoDemandaController {

@Inject

private DemandaService demandaService;

Jboss / Ágiles

Crie um diretório para armazenar as configurações de projetos que serão integrados

ao Ágiles (ex. C:\Development\agiles-configs\config). Descompacte o conteúdo do arquivo agiles_configs.zip neste diretório de forma que o

arquivo _agiles-jboss5.bat fique diretamente no diretório de configurações (no exemplo, c:/agiles/configs/_agiles-jboss5.bat).

Configure o arquivo _agiles-jboss5.bat com o diretório de instalação do JBoss 5. Insira no arquivo server/standard/conf/bootstrap/profile.xml (dentro do diretório de

instalação do JBoss 5) a propriedade agiles.ear.deploy como diretório de deployment. Exemplo:

...

<property name="applicationURIs">

<list elementClass="java.net.URI">

<value>${jboss.server.home.url}deploy</value>

<value>${agiles.ear.deploy}</value>

</list>

</property>

...

Insira também no arquivo server/standard/conf/bootstrap/vfs.xml a propriedade agiles.ear.deploy. Exemplo: ...

<property name="permanentRoots">

<map keyClass="java.net.URL"

valueClass="org.jboss.virtual.spi.ExceptionHandler">

...

https://imagetec.jira.com/wiki/download/attachments/3408029/agiles_configs.zip?version=1&modificationDate=1296571753943&api=v2

103

<entry>

<key>${agiles.ear.deploy}</key>

<value><inject bean="VfsNamesExceptionHandler"/></value>

</entry>

</map>

</property>

...

Caso deseje habilitar a porta para debug, retire o comentário no arquivo

bin/run.conf.bat referente à linha de debug (a penúltima linha do arquivo). Repare que a porta

default é a 8787, podendo ser alterada para outra porta desejada.

Arquivo agiles-webform.properties

Para que o Ágiles consiga saber qual a url correta para acessar a aplicação é preciso

configurar o arquivo agiles-webform.properties que está localizado na pasta de configurações

do Ágiles junto do arquivo agiles.properties. O conteúdo típico desse arquivo é exibido abaixo

agiles-webform.properties

agiles.context=http://<ip_do_agiles>:<porta_do_agiles>/agiles

webform.server=http://<ip_da_aplicacao>:<porta_da_aplicacao>

Desenvolvimento do projeto

Criação de uma nova entidade

Cada entidade do sistema é mapeada automaticamente para o banco de dados através

de anotações JPA nas classes de entidades. Todas as anotações citadas nesta etapa são da

especificação JPA e se encontram no pacote javax.persistence.

Criação de entidades

104

Para criar uma nova entidade, é necessário criar uma classe para a entidade no

módulo model de acordo com as convenções de nomenclatura, anotar a classe com a

anotação @Entity, definir os atributos, o atributo identificador e os relacionamentos da

entidade.

Exemplo de uma classe simples:

@Entity

public class Solicitacao { ...

}

Criação de atributos

Criar o atributo na entidade utilizando uma classe wrapper (Long, Integer) em vez dos

tipos primitivos (long, int).

Configurar, se necessário, a criação do atributo no banco de dados utilizando os

parâmetros da anotação @Column (nullable, length, unique etc).

Criar o getter e o setter correspondentes ao novo atributo.

Exemplo:

@Entity

public class Solicitacao {

...

private Date dataConclusao;

@Column(nullable = false)

private BigDecimal valorPago;

...

}

Definição do atributo Identificador

Para criar um atributo identificador, basta anotá-lo com a anotação @Id. Se for

necessário gerar o identificador, utilizar as anotações @SequenceGenerator e

@GeneratedValue, como no exemplo a seguir:

@Entity

https://imagetec.jira.com/wiki/display/ASDK/Model


105


@Id

@SequenceGenerator(name = "Solicitacao", sequenceName

= "seq_solicitacao", allocationSize = 1)

@GeneratedValue(strategy = GenerationType.AUTO, generator

= "Solicitacao")

private Long id;

...

}

Utilização de enumerações

Para utilizar uma enumeração em uma entidade, basta:

Criar um atributo definido com a enumeração.

Anotar o atributo com a anotação @Enumerated utilizando sempre o tipo

EnumType.STRING.

Exemplo:

@Entitypublic class Solicitacao {}

...

@Enumerated(EnumType.STRING)

@Column(length = 30)

private TipoSolicitacaoEnum tipo;

...

}

Definição de relacionamentos entre entidades

Há quatro tipos básicos de relacionamento entre entidades: um-para-um, um-para-

muitos, muitos-para-um e muitos-para-muitos. Estes tipos de relacionamento são definidos,

respectivamente, pelas anotações @OneToOne, @OneToMany, @ManyToOne,

@ManyToMany. Estas anotações devem ser aplicadas na declaração de um atributo com o

tipo da entidade de destino do relacionamento. Esta declaração é inserida na entidade de

origem do relacionamento.

106

Exemplos:

@Entity


...

@ManyToOne

private PermissaoEspecial permissaoEspecial;

@ManyToOne(optional = false)

private Ato ato;

@ManyToMany

@JoinTable(name = "jc_solicitacao_eventos")

private List<Evento> eventos;

...

}

Herança de entidades

É possível mapear relacionamentos de generalização/especialização entre os objetos

para o banco de dados utilizando as anotações @Inheritance e @DiscriminatorColumn, como

no exemplo a seguir:

@Entity

@Inheritance(strategy = InheritanceType.JOINED)

@DiscriminatorColumn(name = "tipo_registro", discriminatorType =

DiscriminatorType.STRING)


...

}

107

Criação de atividade de usuário

Para criar uma Action de atividade de usuário, basta:

1. Criar uma classe herdeira de BaseJpaActivityAction no módulo view, de acordo

com as convenções de nomenclatura.

2. Implementar o método exibirAtividade para montar os dados que serão

exibidos na tela do usuário.

3. Implementar o método concluirAtividade para tratar os dados recebidos da

tela do usuário antes da conclusão da atividade.

4. Se necessário, implementar o método salvarAtividade para armazenar os

dados recebidos da tela do usuário sem que a atividade seja concluída.

5. Criar uma JSP, um CSS e um JS correspondentes à Action também de acordo

com as convenções de nomenclatura.

Exemplo:

public class ValidacaoNotaAction extends BaseJpaActivityAction {

@Inject

private ValidacaoNotaActionController

validacaoNotaActionController;

...

public String exibirAtividade(boolean atividadeAtiva) {

...

}

public void concluirAtividade() {

...

}

}

https://imagetec.jira.com/wiki/display/ASDK/View


108

Camadas de Serviço

109

Funções

Abaixo esta relacionada às funções da biblioteca padrão no Ágiles.

BasicRoles

Funções relacionadas a usuários, grupos e nós organizacionais.

• addArrays(User[], User[]):User[]

– adiciona arrays de usuários, usado para compor regras complexas

• getUserByExactName(String): User[]

– busca usuários pelo nome (login)

• getUserByName(String): User[]

– busca usuários por parte do nome

• getUserbyPK(ItemPK): User[]

• getUserbyPK(String): User[]

– Busca usuário pela PK (em forma normal ou de string)

• getUserFromGroup(Group):User[]

• getUserFromGroup(ItemPK) :User[]

• getUserFromGroup(String):User[]

– Obtém os usuários de um grupo

• getUserbyPK(ItemPK): User[]

• getUserbyPK(String): User[]

– Busca usuário pela PK (em forma normal ou de string)

• getUserFromGroup(Group):User[]

• getUserFromGroup(ItemPK) :User[]

• getUserFromGroup(String):User[]

– Obtém os usuários de um grupo

110

• getUserFromGroups(ItemPK[])

– Obtém os usuários de vários grupos

• getUsersbyPK(ItemPK[])

– Obtém vários usuários pela PK

Conversion

• characterToInteger(Character): Integer

– Obtém o valor Unicode de um caractere

• formatDate(Date, String): String

– Formata uma data segundo um padrão

– Esse padrão é o mesmo da classe SimpleDateFormat do Java

• formatNumber(Integer, String): String

– Formata um inteiro segundo um padrão

– Esse padrão é o mesmo da classe DecimalFormat do Java

• integerToCharacter(Integer): Character

– Converte um inteiro em um caractere (pelo valor unicode)

• parseBoolean(String): Boolean

– Transforma uma String (true / false) em Boolean

• parseDate(String, String): Date

– Transforma uma String segundo um padrão

– Segue o formato do SimpleDateFormat do Java

• parseDouble(String): Double

– Transforma uma String em um Double

• parseFloat(String): Float

– Transforma uma String em um Float

• parseInt(String): Integer

111

– Transforma uma String em um Inteiro

• parseLong(String): Long

– Transforma uma String em um Long

• parsePK(String): ItemPK

– Transforma uma String em uma PK

• toPKArray(String[]): ItemPK[]

– Converte um array de Strings em um array de pks

• toString(Object):String

– Converte um objeto em String (equivalente a object.toString()

Date

• dateAdd(Date, Date): Date

– Adiciona duas datas (por exemplo, agora mais 10 dias)

• dateSub(Date, Date): Date

– Subtrai duas datas

• days(Integer): Date

– Data equivalente a x dias

• get(String, Date): Integer

– Retorna um pedaço de uma data,

– Exempo: get(“DAY_OF_MONTH”, new Date()) retorna o dia atual

• hours(Integer): Date

– Data equivalente a x horas

• minutes(Integer): Date

– Data equivalente a x minutos

• months(Integer): Date

– Data equivalente a x meses

112

• seconds(Integer): Date

– Data equivalente a x segundos

• weeks(Integer): Date

– Data equivalente a x semanas

• years(Integer): Date

– Data equivalente a x anos

Form

• append(Form, String, String): Boolean

– Adiciona uma string ao final de um campo:

• append(form, “NOME_CAMPO”, “adicionado no final do campo”)

• assign(Form, String, Object): Boolean

– Seta um valor em um campo

• assign(form, “NOME_CAMPO”, “Valor novo”)

• assignOption(Form, String, Object):Boolean

– Seta um valor em um campo do tipo option

• assignOption(form, “NOME_CAMPO”, “Opção”)

• checkArrayEmpty(Form, String): Boolean

– Verifica se um campo do tipo array é vazio

• getArrayLength(Form, String): Integer

– Retorna o tamanho de um campo do tipo array

• getFromArray(Form, String, Integer)

– Obtém um valor de um array

• getCurrentSequencial(String[], String[]): Integer

• getNextSequencial(String[], String[]): Integer

– Obtém o valor atual ou o próximo de um sequencial

113

• getValue(Form, String): Object

– Obtém o valor de um campo

• pushIntoArray(Form, String, String) : Boolean

– Adiciona um valor na última posição de um campo array

• removeLine(Form, Integer, String[]) : Boolean

– Remove uma linha de um array (o último parametro são os nomes dos

campos)

• setIntoArray(Form, String, Integer, String) : Boolean

– Seta o valor em um array (na posição especificada)

ItemFunctions

• addRelatedItem(Item, Item): Boolean

– Relaciona dois items

• getItemFromContainer(Container, String): Item

– Retorna um item de um container pelo nome

– Case Sensitive

ItemMetaData

• checkIfExists(String, String, String): Boolean

– Verifica a existência de um metadado em um conjunto de items

• checkIfExists(“119-3;119-2”, “METADADO”, null)

• checkIfExists(“119-3;119-2”, “METADADO”, “VALOR”)

• getMetaData(Item, String): Boolean

– Obtém o valor de um metadado

• setMetaData(Item, String, String): String

– Seta o valor de um metadado

114

Logic

• and(Boolean, Boolean): Boolean

– B1 && B2

• not(Boolean): Boolean

– !B1

• or(Boolean, Boolean): Boolean

– B1 || B2

• xor(Boolean, Boolean):Boolean

– B1 xor B2

• equals(Object, Object): Boolean

– o1.equals(o2)

• instanceOf(Object, String): Boolean

– o1 instanceof Class.forName(s2)

• isNull(Object): Boolean

– o1 == null

• greater(Double, Double): Boolean

– d1 > d2

• greaterOrEqual(Double, Double): Boolean

– d1 >= d2

• lower(Double, Double): Boolean

– d1 < d2

• lowerOrEqual(Double, Double): Boolean

– d1 <= d2

115

Math

• add(Double, Double): Double

– d1 + d2

• divide(Double, Double) : Double

– d1 / d2

• minus(Double, Double) : Double

– d1 - d2

• pow(Double, Double) : Double

– d1^d2

• times(Double, Double) : Double

– d1 * d2

PropertiesFunctions

• getProperties(String): Properties

– Obtém um conjunto de propriedades vindos de um arquivo no diretório de

config do Ágiles

• getProperty(Properties, String): String

– Obtém uma propriedade de um arquivo

Util

• concatString(String[]): String

– Concatena um array se Strings em uma String

• replace(String, String, String): String

– s1.replaceAll(s2,s3)

• formatString(String, String[]): String

116

– Formata uma String

• formatString(“%0 %1”, {“Hello”, “World”}

• createVisitorFolder(String, String, Boolean): String

– Cria uma pasta no visitor

• createVisitorFolder( “Nome Pasta”, “32-1”, herdarPermissao)

• createVisitorFolder(String, String): String

– createVisitorFolder(s1,s2,TRUE)

• createVisitorFolders(String, String, Boolean): String

– Cria um caminho no visitor

• createVisitorFolders(“pasta1/Pasta2”, “32-1”, herdarPermissao)

• createVisitorFolders(String, String) : String

– createVisitorFolders(s1,s2,TRUE)

• publish(VisitorFolder, Item[]): Boolean

– Publica um conjunto de Itens em uma pasta

• publish(VisitorFolder, List) : Boolean

– Publica um conjunto de Itens em uma pasta

• publishSingle(VisitorFolder, Item): Boolean

– Publica um item em uma pasta

• unpublishSingle(Item): Boolean

– Despublica um item de todas as pastas

• getContainerContents(Container): Item[]

– Retorna o conteudo de um Container

• getItem(ItemPK): Item

– Retorna um item a partir de uma PK

• getStringPK(Item): String

117

– Returna a PK de um item

• getProperty(Object, String): Object

– Obtém o valor de uma propriedade de um Java Bean

• setProperty(Object, String, Object): Boolean

– Seta o valor de uma propriedade de um Java Bean

• checkProcessConclusion(ProcessInstance, String): Boolean

– Verifica se todos os subprocessos foram concluídos

• suspendActivity(String ): Boolean

– Suspende uma atividade (pelo PK)

• suspendEventByTemplateName(ProcessInstance, String ): Boolean

– Suspende um evento de um processo pelo seu nome

118

WS-Function

Criação de uma função que será chamada pelo Ágiles

Para criar uma WS-Function, basta:

1. Criar no módulo functions uma interface, de acordo com as convenções de nomenclatura, com

a anotação @WebService, definindo os parâmetros name e targetNamespace.

2. Inserir uma referência à interface no arquivo agiles.xml, localizado no módulo functions.

3. Criar no módulo controller uma implementação desta interface, herdeira da classe

AbstractFunctions, também de acordo com as convenções de nomenclatura, com a anotação

@WebService, definindo os parâmetros endpointInterface, portName, serviceName e

targetNamespace.

4. Fazer o binding da interface e da implementação no Guice (geralmente na classe

CommonModule).

5. Publicar o serviço no servlet de inicialização dos serviços do projeto (geralmente na classe

FunctionServices).

6. Configurar os dados de autenticação da function no arquivo ws-functions-configuration.xml,

localizado no diretório ws-functions, localizado no diretório de configuração do Ágiles.

Exemplo de interface:

package br.com.imagetec.novo.projeto.functions;

...

@WebService(name = "PagamentoFunctions", targetNamespace

= "http://imagetechnology.com.br/novo_projeto")

public interface PagamentoFunctions {

...

}

Exemplo de implementação:

package br.com.imagetec.novo.projeto.functions;

...

https://imagetec.jira.com/wiki/display/ASDK/Functions


https://imagetec.jira.com/wiki/display/ASDK/Controller

http://imagetechnology.com.br/novo_projeto

119

@WebService(endpointInterface

= "br.com.imagetec.novo.projeto.functions.PagamentoFunctions",

portName = "PagamentoFunctionsPort", serviceName

= "PagamentoFunctions",

targetNamespace = "http://imagetechnology.com.br/novo_projeto")

public class PagamentoFunctionsImpl extends AbstractFunctions implemen

ts PagamentoFunctions {

...

}

Exemplo do arquivo agiles.xml:

<?xml version="1.0" encoding="iso-8859-1"?>



<agilesDescriptor>

<functionLibraries>

...

<wsFunctionLibrary>

<name>PagamentoFunctions</name>

<className>br.com.imagetec.junta.digital.rn.functions.Pagamen

toFunctions</className>

</wsFunctionLibrary>

...

</functionLibraries>

</agilesDescriptor>

Exemplo do binding no Guice:

public class CommonModule extends AbstractJpaModule {

http://imagetechnology.com.br/novo_projeto

120

...

protected void doConfigure() {

...

bind(PagamentoFunctions.class).to(PagamentoFunctionsImpl.class);

...

}

...

}

Exemplo da publicação do serviço:

public class FunctionServices extends AbstractServicesInitializationSe

rvlet {

...

protected void initServices() {

...

publish("/PagamentoFunctions",

InjectionContext.get(PagamentoFunctions.class));

...

}

...

}

Exemplo da configuração de autenticação:

<?xml version="1.0" encoding="iso-8859-1"?>

<list>

...

121

<function>

<name>PagamentoFunctions</name>

<wsdl>http://localhost:8081/novo-

projeto/services/PagamentoFunctions?wsdl</wsdl>

<key>agiles</key>

<token>agiles</token>

</function>

...

</list>

122

Object Type

Object Type é uma funcionalidade do Ágiles que permite a definição de tipos de

Objetos e armazenamento de instâncias dos mesmos.

O template do Abject Type defini quais os atributos, ações, eventos e telas que serão

associados.

Lista de Atributo

Nesta opção são definidos os atributos do OT:

123

Atributo ligado a um ObjectTypeTemplate. Possui nome, nome para visualização e um

tipo. Os tipos possíveis são:

Item – Objeto do Ágiles. Pode ser um usuário, processo, documento, formulário, ou

qualquer outro objeto.

Texto – Texto corrido

Boolean – Valor verdadeiro ou falso

Data – Uma data, pode ter seu formato determinado pelo usuário.

Numérico – Formato numérico pode ter seu formato determinado pelo usuário

Tempo – Hora, dia, minuto e segundo, pode ter seu formato determinado pelo

usuário.

Seleção – O usuário determina valores possíveis para os atributos.

Custom – O usuário determina o que o campo aceita, especificando uma expressão

regular

Expression – Aceita expressões, pode ser usado para buscar um dado em um sistema

legado automaticamente.

Para criar um atributo, deve-se escolher seu tipo e depois clicar no botão “Adicionar

Novo”.

124

E na próxima tela preencher os dados do novo atributo.

E depois clicar em “Salvar”.

Lista de Ações

Uma ação que pode ser disparada por um usuário. Essa ação possui uma pré-condição

que determina quando ou por quem a mesma pode ser disparada e uma expressão e/ou regra

de execução (que pode ser um Script).

125

Entre as ações que podem ser disponibilizadas incluem-se check-in e check-out

(exclusivo ou não), envios de e-mails e disparo de processos, como solicitação de revisão e

impressão (tendo opcionalmente o ObjectTypeInstance como metadado dos processos

disparados)

126

Lista de Eventos Temporais

Um evento que ocorre em um momento determinado (por regra definida pelo

usuário).

Possui uma data válida para ser executada (expressão) e uma ação para disparar.

Essa expressão pode conter uma data fixa, uma data periódica (por exemplo, a cada 1

hora, ou em todas as terças-feiras), ou uma data dependente da temporalidade de um

documento, por exemplo, seis meses a partir da data de publicação.

Com essa funcionalidade é possível criar, para cada tipo de documento, uma tabela de

temporalidade, com revisões periódicas, ou reter e apagar documentos conforme uma

temporalidade definida.

127

Lista de Telas

Para cada objeto podem ser disponibilizadas diversas telas (controladas pelo perfil do

usuário), como por exemplo, um documento, os dados do ObjectType, uma aplicação externa,

as versões anteriores de um documento, entre outros.

Lista de Fases

Utilizando fases é possível agendar que determinado processo seja iniciado

automaticamente depois de determinado tempo em relação a uma data.

Antes de agendar uma fase, é necessário cria-la. Para isso, na tela principal de Modelos

de Object Type, deve-se clicar em “Editar Tipos de fases”.

Deve-se clicar no botão “Editar Tipos de Fases”

128

Em seguida deve-se clicar no botão “Adicionar Novo”

Na próxima tela deve preencher no campo “Nome da Fase” com o nome que será

atribuído a essa fase.

E no campo “PK do Processo” com a Pk do processo que será agendado o inicio

automático.

Depois de criada a fase, dentro da tela de “Lista de Fases” agendasse o disparo da fase.

129

No campo “Fase” deve-se preencher qual fase que será executada.

Em “Atributo Data Base” deve preencher em relação de qual data será calculado o disparo,

pode ser em relação a um atributo (do tipo date) do OT, ou em relação à data da criação do

OT.

E nos campos de “Tempo Até Ativação” preenche com tempo que o sistema deve

aguardar depois da “data base” para disparar o processo.

130

Admin Commands

Como criar adminConsoleCommands

Um adminConsoleCommand é uma classe Java que obedece a interface AdminConsoleCommand e está registrada dentro de um arquivo jar disponibilizado na pasta de libs registrada no Ágiles através do arquivo “agiles.properties”. No instante de deploy do Ágiles, todas as libs encontradas nesta pasta serão carregadas e caso possuam funções em seu conteúdo, estas serão disponibilizadas para os processos dentro do Ágiles.

Uma classe Java para se tornar adminConsoleCommand deve obedecer os seguintes requisitos:

Implementar a interface AdminConsoleCommand ou estender a classe

AbstractAdminConsoleCommand

Não poderá possuir atributos de nenhuma espécie ou qualquer tipo de controle

estado da Biblioteca, visto que ela será utilizada simultaneamente em diversos

processos.

Não poderá ser estática nem mesmo final, pois o Ágiles deve conseguir manipular

estas classes.

Não poderá ter seu construtor privado.

Estar devidamente registrada no arquivo agiles.xml na pasta META-INF dentro do

respectivo Jar da função.

Deve no mínimo implementar o método executeCommand e sobrescrever os

métodos getHelpMessage e getDetailedHelpMessage.

Exemplo de adminConsoleCommand

AddProcessOwner.java package br.com.imagetec.agiles.console.commands; import br.com.imagetec.agiles.adminConsole.AbstractAdminConsoleCommand; import br.com.imagetec.auditTrail.action.Result; import br.com.imagetec.auditTrail.action.Result.ResultType; public class AddProcessOwner extends AbstractAdminConsoleCommand { public String getCommandPrototype() { return "addProcessOwner {processInstancePK} {userPK | userName}"; }

131

public String getHelpMessage() { return “This method adds a process owner to the specified process.”; } public String getDetailedHelpMessage() { StringBuffer message = new StringBuffer(); message.append("This method adds a process owner to the specified process.\n"); message.append(" I.E.:\n"); message.append(" \"addProcessOwner 19-71 vila\" (adds user 'vila' to process '19-71'\n"); return message.toString(); } public void executeCommand(String fullCommand, Result result, User user) { String[] commands = fullCommand.split(" "); if (commands.length == 3) { String processPK = commands[1]; String userPK = commands[2]; try { … println("granted."); } catch (Exception ex) { ex.printStackTrace(this.getStream()); result.setException(ex); result.setResult(ResultType.SYSTEM_EXCEPTION); } } else { print("One or more arguments are missing."); } } }

132

Nós Organizacionais

Dimensões e Níveis Organizacionais

Permite o cadastramento de dimensões e níveis organizacionais, representando a

hierarquia da empresa (divisões, unidades, diretorias, cargos).

Por exemplo, é possível elaborar uma estrutura onde, numa empresa existam duas

unidades (São Paulo e Rio de Janeiro) e dois níveis de cargo (Gerente e Diretor).

133

Para criar os níveis é deve-se utilizado o botão “Adicionar Nivel”.

Montada essa estrutura no modulo “Estrutura organizacional” serão criados os Nós

para relacionar aos usuários.

134

Estrutura Organizacional

Permite relacionar as dimensões e níveis com os usuários e grupos, criando "nós

organizacionais". Os nós informam quais usuários e/ou grupos respondem por cada função /

área.

Na inclusão de nós organizacionais, digite o nome e descrição, e clique em "Definir

Nível" para escolher a dimensão e o nível que deseja associar. Deve-se utilizar o botão "Definir

Nível" quantas vezes forem necessárias para completar a estrutura deste nó.

136

Módulos Externos

Para criar uma Action de módulo externo, basta:

1. Criar uma classe herdeira de BaseJpaExternalModuleAction no módulo view, de

acordo com as convenções de nomenclatura.

2. Implementar o método execute para montar os dados que serão exibidos na tela

do usuário.

3. Criar uma JSP, um CSS e um JS correspondentes à Action também de acordo com

as convenções de nomenclatura.

Exemplo:

public class RelatorioPagamentosAction extends BaseJpaExternalModuleAc

tion {

@Inject

private RelatorioPagamentosActionController

relatorioPagamentosActionController;

...

public String execute() {

...

}

}

https://imagetec.jira.com/wiki/display/ASDK/View


137

Ldap

Especificação

A comunicação do Ágiles com o Active Directory é feita através de uma ponte chamada Ágiles LDAP Connector. A implementação desta ponte é diferente para cada ambiente, uma vez que é utilizada para realizar o mapeamento das informações já existentes no Active Directory para o Ágiles. Estas informações são recuperadas em real-time, ou seja, não é realizada em momento algum a cópia dos dados lidos para o banco de dados do Ágiles. Sendo assim, não há necessidade de atualizar o mesmo conjunto de dados em mais de um sistema e tampouco de realizar importações periódicas de dados.

As informações que o Ágiles irá recuperar do Active Directory são relativas aos usuários do sistema, grupos e nós organizacionais.

Com relação aos usuários, as informações são utilizadas para permitir o login no sistema com o mesmo nome de usuário e senha usados no Active Directory, além de serem utilizadas como fonte de dados para preenchimento de campos relevantes ao Ágiles tais como nome e endereço de e-mail.

Os grupos são utilizados para agrupar os usuários do sistema que realizam uma determinada função, independente de sua posição dentro da organização. Desta forma, os grupos podem ser utilizados para definir permissões de acesso a um conjunto de usuários e também para permitir a separação de usuários por função nos processos. As informações do Active Directory são utilizadas para definir os grupos aos quais os usuários pertencem.

Os nós organizacionais têm uma função semelhante aos grupos, com a diferença de que a sua disposição representa uma hierarquia com várias dimensões. Uma utilização comum de nós organizacionais é representar uma hierarquia de cargos e departamentos, possibilitando ao Ágiles recuperar informações da estrutura organizacional.

As necessidades técnicas do ambiente do Active Directory para a implantação do Ágiles LDAP Connector são as seguintes:

- Deve existir uma conta de usuário que será utilizada pelo Ágiles para realizar pesquisas e recuperar dados;

- Para o caso de múltiplos domínios, deve haver relação de confiança entre eles;

- Deve haver um atributo para cada usuário, grupo e nó organizacional (não necessariamente o mesmo atributo para estes três tipos de elemento) que possa ser utilizado como chave primária, ou seja, que identifique única e exclusivamente o elemento em questão;

- Deve haver uma OU separada para grupos e outra para nós organizacionais;

138

- Caso seja necessária à utilização de group nesting no Ágiles, o Active Directory não pode estar em mixed-mode.

Procedimento de Instalação

1) O Active Directory já deve possuir as informações de usuários, grupos e nós organizacionais, bem como o relacionamento entre usuários e grupos e entre usuários e nós organizacionais.

2) O JAR que contém os DAOs externos (agilesLdapConnector.jar) deve ser colocado no diretório de lib do Ágiles;

3) O XML que contém as configurações dos DAOs externos (external_dao_config.xml) deve ser colocado no diretório de configuração do Ágiles (o mesmo diretório que contém o arquivo agiles.properties);

4) O valor da propriedade security.ldap.enable do arquivo agiles.properties deve ser true;

5) O arquivo ldap.properties deve ser colocado no diretório de configuração do Ágiles (o mesmo diretório que contém o arquivo agiles.properties) e deve ser configurado de acordo com as configurações descritas na seção “Configuração do Ágiles LDAP Connector” deste documento;

6) O arquivo user_setup.xml deve ser configurado de acordo com as configurações descritas na seção “Configuração do User Setup” deste documento e, posteriormente, copiado para o diretório de configuração do Ágiles;

7) O WAR que contém o LDAP Login Manager (ldapLoginManager.war) deve ser instalado no servidor de aplicação;

8) O Ágiles deve ser executado para criar as tabelas no banco de dados e realizar todas as configurações necessárias para o seu funcionamento.

Configuração do Ágiles LDAP Connector

As configurações do Ágiles LDAP Connector são definidas no arquivo ldap.properties. Este arquivo se divide em quatro seções: Default Configs, Groups, Nodes e Users. Estas seções são relativas, respectivamente, a configurações default, grupos, nós organizacionais e usuários.

LDAP Login Manager

139

A seção LDAP Login Manager define três propriedades que são utilizadas para configurar a forma com que os usuários irão fazer login no Ágiles utilizando as informações do Active Directory, definidas a seguir:

Propriedade Descrição Exemplo de preenchimento ldap.loginManager.context Contexto da aplicação web

responsável pelo login de usuários no Ágiles com informações do Active Directory.

ldapLoginManager

ldap.loginManager.agilesLoginAction Caminho dentro do contexto do Ágiles para a action que realiza o login do usuário.

login.do

ldap.loginManager.domains Lista de todos domínios que serão utilizados para fazer login no Ágiles, separados por ponto-e-vírgula.

matrix.local;neo.matrix.local

Default Configs

A seção Default Configs define seis propriedades que serão utilizadas em caso de

omissão de alguma propriedade correspondente em alguma outra seção. Sendo assim, estas propriedades são sobreescritas pelas configurações personalizadas das outras seções. Estas propriedades estão definidas a seguir:

Propriedade Descrição Exemplo de preenchimento

ldap.configs.serverAddress Endereço do controlador de domínio. ldap://morpheus-server:389/ ldap.configs.domainBase Caminho até o nó base do domínio. DC=matrix,DC=local ldap.configs.user Conta de usuário que o Ágiles utilizará para realizar

queries no AD. [email protected]

ldap.configs.password Password da conta de usuário do Ágiles no AD. Password ldap.configs.authentication Modo de autenticação do usuário no AD (none, simple,

strong). simple

ldap.configs.batchSize Batch size para buscas. Favor acessar o endereço java.sun.com/products/jndi/tutorial/ldap/search/batch.html para maiores informações.

1

ldap.configs.querySize Query size para buscas de elementos que possuem root group (no caso, apenas para usuários). Utilizado em algumas queries que necessitam definir uma grande quantidade de parâmetros para fazer buscas parciais. Por exemplo, no caso de uma busca com 50 parâmetros utilizando querySize igual a 10, serão realizadas 5 queries no AD com 10 parâmetros cada para a execução completa da busca.

10

Groups

A seguir estão relacionadas às propriedades básicas de grupos, que definem as configurações utilizadas para ler dados que estão separados entre múltiplos domínios. Para ajustar o valor das propriedades para mais de um domínio, é necessário especificar a quantidade de controladores de domínio utilizando a propriedade ldap.group.configs.size. As propriedades de cada domínio deverão ser agrupadas utilizando um valor inteiro maior ou

140

igual a 0 e menor que o valor definido em ldap.group.configs.size. As propriedades deverão ser definidas de acordo com o padrão ldap.group.configs.<num>.<propriedade>, onde <num> é valor inteiro utilizado para agrupar as configurações de um domínio e <propriedade> é o nome da propriedade.

Propriedade Descrição Exemplo de preenchimento ldap.group.configs.size Número de configurações básicas

diferentes a utilizar. 1

ldap.group.configs.<num>.serverAddress Ver propriedade default ldap.configs.serverAddress. Se omitida, utiliza o valor desta propriedade default.

ldap://morpheus-server:389/

ldap.group.configs.<num>.domainBase Ver propriedade default ldap.configs.domainBase. Se omitida, utiliza o valor desta propriedade default

DC=matrix,DC=local

ldap.group.configs.<num>.user Ver propriedade default ldap.configs.user. Se omitida, utiliza o valor desta propriedade default.

[email protected]

ldap.group.configs.<num>.password Ver propriedade default ldap.configs.password. Se omitida, utiliza o valor desta propriedade default.

password

ldap.group.configs.<num>.authentication Ver propriedade default ldap.configs.authentication. Se omitida, utiliza o valor desta propriedade default.

simple

ldap.group.configs.<num>.batchSize Ver propriedade default ldap.configs.batchSize. Se omitida, utiliza o valor desta propriedade default.

1

ldap.group.configs.<num>.querySize Ver propriedade default ldap.configs.querySize. Se omitida, utiliza o valor desta propriedade default.

10

ldap.group.configs.<num>.home Caminho até a OU que armazena os grupos.

OU=Groups,OU=Root

ldap.group.configs.<num>.findersEnabled Ativa ou desativa a busca utilizando finders para o domínio em questão. Utilizar sempre o valor true para configuração de grupos.

true

ldap.group.configs.<num>.searchScope Escopo de busca utilizado para definir a profundidade da query na árvore do AD. Os valores possíveis são “ONELEVEL_SCOPE” (busca apenas um nível abaixo do home) e “SUBTREE_SCOPE” (busca em toda a subárvore abaixo do home). O valor default é ONELEVEL_SCOPE.

ONELEVEL_SCOPE

A seguir estão relacionadas às demais propriedades relativas a grupos:


ldap.groupAttributes.key Nome do atributo do Active Directory que armazena a PK do grupo.

name

ldap.groupAttributes.name Nome do atributo do Active Directory que armazena o nome do grupo.

name

ldap.groupAttributes.memberOf Nome do atributo do Active memberOf

141

Directory que informa a quais Security Groups do Active Directoty o grupo pertence.

ldap.groupAttributes.ldapName Nome do atributo do Active Directory que armazena o nome do grupo na notação de LDAP.

distinguishedName

ldap.groupAttributes.objectClass Nome do atributo do Active Directory que armazena a classe do objeto.

objectClass

ldap.groupAttributes.members Nome do atributo do Active Directory que informa quais são os elementos que pertencem ao grupo.

member

ldap.groupValues.objectClass Classe do objeto. O valor deve ser group.

group

ldap.groupValues.namePrefix Prefixo do nome do grupo. D_INTRANET_A_AGILES_G_ ldap.groupValues.visitorGroupKey PK do grupo que será utilizado

como Visitor. D_INTRANET_A_AGILES_G_VISITORS

Nodes

A seguir estão relacionadas às propriedades básicas de nós organizacionais, que definem as configurações utilizadas para ler dados que estão separados entre múltiplos domínios. Para ajustar o valor das propriedades para mais de um domínio, é necessário especificar a quantidade de controladores de domínio utilizando a propriedade ldap.nodes.configs.size. As propriedades de cada domínio deverão ser agrupadas utilizando um valor inteiro maior ou igual a 0 e menor que o valor definido em ldap.nodes.configs.size. As propriedades deverão ser definidas de acordo com o padrão ldap.nodes.configs.<num>.<propriedade>, onde <num> é valor inteiro utilizado para agrupar as configurações de um domínio e <propriedade> é o nome da propriedade.

Propriedade Descrição Exemplo de preenchimento ldap.node.configs.size Número de configurações básicas

diferentes a utilizar. 1

ldap.node.configs.<num>.serverAddress Ver propriedade default ldap.configs.serverAddress. Se omitida, utiliza o valor desta propriedade default.


ldap.node.configs.<num>.domainBase Ver propriedade default ldap.configs.domainBase. Se omitida, utiliza o valor desta propriedade default.

DC=matrix,DC=local

ldap.node.configs.<num>.user Ver propriedade default ldap.configs.user. Se omitida, utiliza o valor desta propriedade default.

[email protected]

ldap.node.configs.<num>.password Ver propriedade default ldap.configs.password. Se omitida, utiliza o valor desta propriedade default.

password

ldap.node.configs.<num>.authentication Ver propriedade default ldap.configs.authentication. Se omitida, utiliza o valor desta propriedade default.

simple

ldap.node.configs.<num>.batchSize Ver propriedade default ldap.configs.batchSize. Se omitida, utiliza o valor desta propriedade default.

1

ldap.node.configs.<num>.querySize Ver propriedade default ldap.configs.querySize.

10

142

Se omitida, utiliza o valor desta propriedade default.

ldap.node.configs.<num>.home Caminho até a OU que armazena os nós organizacionais

OU=Nodes,OU=Root

ldap.node.configs.<num>.findersEnabled Ativa ou desativa a busca utilizando finders para o domínio em questão. Utilizar sempre o valor true para configuração de nós organizacionais.

true

ldap. node.configs.<num>.searchScope Escopo de busca utilizado para definir a profundidade da query na árvore do AD. Os valores possíveis são “ONELEVEL_SCOPE” (busca apenas um nível abaixo do home) e “SUBTREE_SCOPE” (busca em toda a subárvore abaixo do home). O valor default é ONELEVEL_SCOPE.

ONELEVEL_SCOPE

A seguir estão relacionadas às demais configurações:


ldap.nodeAttributes.key Nome do atributo do Active Directory que armazena a PK do nó organizacional.

name

ldap.nodeAttributes.name Nome do atributo do Active Directory que armazena o nome do nó organizacional.

name

ldap.nodeAttributes.memberOf Nome do atributo do Active Directory que informa a quais Security Groups do Active Directory o nó organizacional pertence

memberOf

ldap.nodeAttributes.ldapName Nome do atributo do Active Directory que armazena o nome do nó organizacional na notação de LDAP.

distinguishedName

ldap.nodeAttributes.objectClass Nome do atributo do Active Directory que armazena a classe do objeto.

objectClass

ldap.nodeAttributes.members Nome do atributo do Active Directory que informa quais são os elementos que pertencem ao grupo.

member

ldap.nodeValues.objectClass Classe do objeto. O valor deve ser group.

group

ldap.nodeValues.namePrefix Prefixo do nome do grupo. D_INTRANET_A_AGILES_N_ ldap.nodeLevels.separator Caractere utilizado para separar os

campos que compõem o nome do nó organizacional.

-

ldap.nodeLevels.indexes Índices dos campos que armazenam os nomes dos níveis organizacionais que definem o nó organizacional, separados por ponto-e-vírgula (;).

5;6

ldap.nodeLevels.dimensions Dimensões dos níveis organizacionais cujos índices são especificados na propriedade ldap.nodeLevels.indexes, dispostos na mesma ordem dos índices.

Cargo;Unidade

143

Users

A seguir estão relacionadas às propriedades básicas de usuários, que definem as configurações utilizadas para ler dados que estão separados entre múltiplos domínios. Para ajustar o valor das propriedades para mais de um domínio, é necessário especificar a quantidade de controladores de domínio utilizando a propriedade ldap.user.configs.size. As propriedades de cada domínio deverão ser agrupadas utilizando um valor inteiro maior ou igual a 0 e menor que o valor definido em ldap.user.configs.size. As propriedades deverão ser definidas de acordo com o padrão ldap.user.configs.<num>.<propriedade>, onde <num> é valor inteiro utilizado para agrupar as configurações de um domínio e <propriedade> é o nome da propriedade. As propriedades que começam com ldap.user.configs.<num>.root.config são referentes ao grupo root dos usuários.

Propriedade Descrição Exemplo de preenchimento ldap.user.configs.size Número de

configurações básicas diferentes a utilizar.

1

ldap.user.configs.<num>.serverAddress

Ver propriedade default ldap.configs.serverAddress. Se omitida, utiliza o valor desta propriedade default.


ldap.user.configs.<num>.domainBase

Ver propriedade default ldap.configs.domainBase. Se omitida, utiliza o valor desta propriedade default.

DC=matrix,DC=local

ldap.user.configs.<num>.user Ver propriedade default ldap.configs.user. Se omitida, utiliza o valor desta propriedade default.

[email protected]

ldap.user.configs.<num>.password Ver propriedade default ldap.configs.password. Se omitida, utiliza o valor desta propriedade default.

password

ldap.user.configs.<num>.authentication

Ver propriedade default ldap.configs.authentication. Se omitida, utiliza o valor desta propriedade default.

simple

ldap.user.configs.<num>.batchSize Ver propriedade default ldap.configs.batchSize. Se omitida, utiliza o valor desta propriedade default.

1

ldap.user.configs.<num>.querySize Ver propriedade default ldap.configs.querySize. Se omitida, utiliza o valor desta propriedade default.

10

ldap.user.configs.<num>.home Caminho até a OU que armazena os usuários.

OU=Users,OU=Root

ldap.user.configs.<num>.root Caminho até o CN=D_INTRANET_A_AGILES_G_USERS,OU=Group

144

Security Group ao qual os usuários pertencem.

s,OU=Root

ldap.user.configs.<num>.root.config. serverAddress

Endereço do controlado de domínio. Ver propriedade default ldap.configs.serverAddress. Se omitida, utiliza o valor desta propriedade default.


ldap.user.configs.<num>.root.config. domainBase

Base do domínio. Ver propriedade default ldap.configs.domainBase. Se omitida, utiliza o valor desta propriedade default.

DC=matrix,DC=local

ldap.user.configs.<num>.root.config. user

Usuário que será utilizado para autenticação no AD. Ver propriedade default ldap.configs.user. Se omitida, utiliza o valor desta propriedade default.

[email protected]

ldap.user.configs.<num>.root.config. password

Password que será utilizada para autenticação no AD. Ver propriedade default ldap.configs.password. Se omitida, utiliza o valor desta propriedade default.

password

ldap.user.configs.<num>.root.config. authentication

Modo de autenticação. Ver propriedade default ldap.configs.authentication. Se omitida, utiliza o valor desta propriedade default

simple

ldap.user.configs.<num>.findersEnabled

Ativa ou desativa a busca utilizando finders para o domínio em questão. Caso haja um ou mais domínios só para usuários visitor, o valor desta propriedade deve ser false para estes domínios.

true

ldap.user.configs.<num>.membersAttribute

Nome do atributo que define a quais grupos um usuário pertence no Active Directory.

member

ldap. user.configs.<num>.searchScope

Escopo de busca utilizado para definir a profundidade da query na árvore do AD. Os valores possíveis são “ONELEVEL_SCOPE” (busca apenas um nível abaixo do home) e “SUBTREE_SCOPE” (busca em toda a sub-árvore abaixo do

ONELEVEL_SCOPE

145

home). O valor default é ONELEVEL_SCOPE.

A seguir estão relacionado ás demais configurações:

Propriedade Descrição Exemplo de preenchimento ldap.userAttributes.key Nome do atributo do Active Directory

que armazena a PK do usuário. name

ldap.userAttributes.name Nome do atributo do Active Directory que armazena o nome do usuário.

name

ldap.userAttributes.memberOf Nome do atributo do Active Directory que informa a quais grupos do Active Directory o usuário pertence.

memberOf

ldap.userAttributes.ldapName Nome do atributo do Active Directory que armazena o nome do usuário na notação de LDAP.

distinguishedName

ldap.userAttributes.objectClass Nome do atributo do Active Directory que armazena a classe do objeto.

objectClass

ldap.userAttributes.mail Nome do atributo do Active Directory que armazena o e-mail do usuário.

mail

ldap.userAttributes.description Nome do atributo do Active Directory que armazena a descrição do usuário.

description

ldap.userAttributes.displayName Nome do atributo do Active Directory que armazena o nome de exibição do usuário.

displayName

ldap.userAttributes.firstName Nome do atributo do Active Directory que armazena o primeiro nome do usuário.

givenName

ldap.userAttributes.lastName Nome do atributo do Active Directory que armazena o último nome do usuário.

sn

ldap.userAttributes.telephoneNumber Nome do atributo do Active Directory que armazena o telefone do usuário.

telephoneNumber

ldap.userAttributes.ldapDomainName Nome do atributo do Active Directory que armazena o nome do usuário na notação de LDAP.

userPrincipalName

ldap.userValues.objectClass Classe do objeto. O valor deve ser user.

user

ldap.userValues.namePrefix Prefixo do nome do usuário. Deixar em branco.

Propriedade

Configuração do User Setup

O Ágiles LDAP Connector necessita da execução de duas tarefas para possibilitar o seu funcionamento correto. A primeira tarefa configura o grupo de Administradores do Ágiles. A segunda tarefa faz a importação dos níveis organizacionais que irão representar os nós organizacionais inseridos no Active Directory. Estas tarefas devem ser especificadas no arquivo user_setup.xml, que deve ser copiado para o diretório de configuração do Ágiles. A tarefa que irá fazer a configuração do grupo de Administradores do Ágiles necessita da especificação do parâmetro administratorsGroupId no arquivo user_setup.xml. O valor deste

146

parâmetro deverá ser a PK do grupo que contém os usuários administradores do Ágiles no Active Directory. Um exemplo de preenchimento das informações desta tarefa é dado a seguir:

<setupTask name="Admin Group Setup"

classname="br.com.imagetec.setup.LdapAdminGroupSetupTask">

<setupParameter name="administratorsGroupId">

D_INTRANET_A_AGILES_G_ADMINISTRATORS

</setupParameter>

</setupTask>

A tarefa que irá fazer a importação dos níveis organizacionais necessita apenas da especificação do parâmetro xmlFileName, cujo valor é nome do arquivo XML que contém as informações relativas à estrutura organizacional que será importada. O arquivo que contém essas informações é o arquivo estrutura_organizacional.xml, que deve ser colocado no diretório de configurações do Ágiles. Um exemplo de preenchimento das informações desta tarefa é dado a seguir:

<setupTask name="Level Importer"

classname="br.com.imagetec.setup.LevelImporterSetupTask">

<setupParameter name="xmlFileName">

estrutura_organizacional.xml

</setupParameter>

</setupTask>

147

Anexo A

IN03 – DOCUMENTO DE ANÁLISE

<NOME DO PROJETO>

Processo: <NOME DO PROCESSO>

<Sigla do Projeto / Processo, se houver>

Versão <nº>

Projeto Nº: <nº>

Classificação: <CONFIDENCIAL, PÚBLICO>

Data: <dd/mm/aaaa>

Autor: <nome do autor do documento>

Cliente: <nome do cliente>

148

APROVAÇÕES

Aprovado por Aprovado em Assinatura

<nome do aprovador> <dd/mm/aaaa>

149

Atualizações

Versão Data Modificado por Descrição

<nº> <dd/mm/aaaa> <nome do

redator>

150

Objetivo do Processo

{Dê preferência para, em vez de criar dois documentos – Especificação de Formulários

(formulários e descrição dos campos) e Mapa Conceitual do Processo (mapa do processo com

descrição das atividades e transições) – criar um único documento de análise com os dois

conteúdos. Na hora de construí-lo, apague este comentário e as demais explicações existentes

no decorrer deste modelo.}

Descrição do processo. Deve ser clara e objetiva. Vide exemplo abaixo.

Exemplo (para Processo de Controle de Cópia Física):

O objetivo deste processo é controlar a geração de cópias físicas (impressão dos documentos

publicados no Ágiles), bem como o empréstimo das mesmas.

Cada vez que um usuário solicita uma cópia física, deve especificar se está solicitando o

empréstimo de uma cópia existente ou a impressão de uma nova.

Em ambas as situações o processo identifica, através do documento, as pessoas que devem ser

notificadas dessa solicitação e quem deverá aprová-la.

Caso o pedido seja aprovado, o solicitante torna-se o novo responsável pela cópia física.

151

Mapa do Processo

Mapa do processo feito no Microsoft Visio com plug-in BPMN, com comentários descrevendo

as atividades.

Utilizar a ferramenta de texto para numerar as atividades e transições seguindo as

regras:

A1, A2, A3, ...: para TODAS as atividades independente do tipo (manual, automática, notificação, sincronia, decisão, sub-processo), ou seja, tudo o que não for transição tem numeração iniciando com a letra “A”.

T1, T2, T3, ...: para as transições.

A numeração começa na primeira atividade após o “Início” (e sua respectiva transição). O evento de “Fim” também não requer número.

A seqüência de numeração deve seguir a ordem das atividades do processo. Quando existir uma decisão ou caminhos diferentes por qualquer outra razão, deve-se estabelecer uma lógica de numeração, por exemplo: o caminho da esquerda será numerado antes do da direita. Na medida do possível esta lógica deve ser mantida em todo o processo.

Inserir uma imagem do processo (verificar a melhor orientação – Retrato ou Paisagem) e com a

maior ampliação possível. A figura abaixo é um exemplo, está com 65% do tamanho normal

apenas para caber nessa página, mas não existindo estas explicações (e rotacionando a figura)

seu tamanho será bem maior e, se necessário, ela poderá ser dividida em mais que uma

página.

153

Dimensões e Nós Organizacionais

Uma Dimensão é a forma como a empresa se divide e se organiza (Unidade, Área,

Departamento, Cargo, por exemplo). Nós Organizacionais são os relacionamentos entre as

dimensões, seus níveis (conteúdos) e os usuários.

Como no momento da elaboração dos documentos de análise, os níveis e usuários podem não

ter sido detalhados ainda (eles serão especificados nos documentos “IN07 - Definição dos

Usuários e Grupos” e “IN08 - Definição de Dimensões, Níveis e Nós”), especificaremos as

Dimensões utilizadas no processo que está sendo mapeado neste documento e os Nós

Organizacionais necessários (cruzamentos entre as dimensões, sem especificação dos

usuários).

Devem ser definidas as dimensões e nós para cada raia do processo. Veja um modelo abaixo.

Raia Dimensões Nós Organizacionais Descrição

Solicitante

Qualquer usuário pode

iniciar o processo deste

exemplo. E, como o

solicitante é o INITIATOR

do processo, não precisa de um nó para identificá-lo.

Responsáveis

pelo Docto

1) Unidade

2) Área

3) Cargo

Unidade do documento,

Área do documento,

Cargo=”Gerente”

Cada documento pertence

a uma unidade e área da

empresa (definidas na

inclusão do docto), e o

gerente desta unidade/área

é o responsável pelos doctos.

Aprovador Idem acima

Unidade do documento,

Área=”Qualidade”,

Cargo=”Coordenador”

Quem aprova as

solicitações é sempre o

Coordenador da área da

Qualidade na Unidade à

qual pertence o documento.

Os Níveis Organizacionais são o conteúdo de cada dimensão (por exemplo, a dimensão

“Unidade” pode ter os níveis “São Paulo”, “Rio de Janeiro” e “Salvador”). Apesar de não ser

obrigatório, é recomendável que se preencha a tabela abaixo especificando os Níveis

Organizacionais de cada dimensão (mesmo que esta informação não seja exata, ela auxiliará

na montagem do “IN08”).

Dimensão Níveis

Unidade Unidade do solicitante, Unidade do documento.

Área Área do solicitante, Área do documento.

154

Cargo Gerente, Coordenador.

Grupos

Se alguma divisão necessária ao processo não pertencer à estrutura organizacional da

empresa, ela não pertencerá aos nós organizacionais e deverá ser definida como grupo. A

especificação dos grupos auxiliará a criação do “IN07 - Definição dos Usuários e Grupos”.

Alguns exemplos: existem os níveis/cargos “Gerente” e “Coordenador”, mas o processo utiliza

“Gerente de Projeto” e “Aprovador”. Neste caso, os dois últimos deveriam ser grupos de

usuários.

Grupo Descrição

Gerente de

Projeto

Pessoas que podem ser responsáveis por projetos, independente

do cargo.

Aprovador Usuários que aprovam solicitações.

155

Formulário do Processo

Desenho do formulário, feito no software de sua preferência (seria interessante que fosse um

HTML, mas não imprescindível), já com os nomes dos campos (em uma cor que destaque bem

com relação à cor do formulário).

Para facilitar a integração entre as equipes de levantamento de dados e a que desenvolverá o

processo no Ágiles, sugere-se que o formulário e os campos sigam algumas regras:

o formulário deve ter suas seções numeradas;

os nomes de campos e seções devem estar em letras maiúsculas;

o nome de cada seção será formado pelas iniciais das palavras, sem os elementos de ligação (“de”, “da”, “para”, etc.), por exemplo: para a seção “DADOS DA SOLICITAÇÃO” o nome seria “DS”;

o nome dos campos deve ser formado pelo nome da seção, um “underscore” e o nome do campo propriamente dito, sem o uso dos elementos de ligação (vide exemplos abaixo);

no nome dos campos NÃO deve haver espaço, utilize um “underscore” no lugar;

no final do formulário devem sempre existir os botões “Salvar” e “Concluir”, e recomenda-se que seus nomes sejam, respectivamente, “doSave” ou “BtnSave” e “doConclude” ou “BtnConclude”. Também deve ter o número e a data da revisão.

157

Descrição dos Campos do Formulário

Nesta área devem ser descritos, na forma de tabela e divididos por seção, os campos do

formulário acima.

É importante citar o “rótulo” do campo (texto / forma como ele aparece no formulário), seu

nome, a descrição do que ele representa, se é obrigatório ou opcional, a origem deste campo

(colocado pelo Ágiles, digitado pelo usuário, proveniente do botão ou formulário X) e, quando

existirem, as regras de validação (maior igual a, datas entre X e Y, etc.).

Vide exemplos abaixo. OS NOMES DOS CAMPOS EM VERMELHO DEVEM SEMPRE EXISTIR!!!

1. DADOS DA SOLICITAÇÃO (DS)

No. (DS_NUM_SOLIC) Número da Solicitação. É colocado pelo Ágiles.

Solicitante (DS_SOLICITANTE)

Nome do Solicitante. Corresponde ao nome do Initiator. É colocado pelo Ágiles.

Data da Solic. (DS_DATA_SOLIC)

Data da Solicitação. Corresponde à data em que o processo foi iniciado. É colocada pelo Ágiles.

Documento (DS_DOCUMENTO_NOME)

Nome do documento. É uma informação obrigatória e não pode ser digitado, deve ser obtido através do botão “Procurar...”.

DS_DOCUMENTO_PK Campo oculto onde será armazenada a PK (código de identificação) do documento.

Botão “Procurar...” (DS_BUTTON_PROCURAR)

Abre uma caixa de diálogo para escolha do documento entre os publicados no Ágiles.

Tipo de Ação (DS_TIPO_ACAO)

Botões mutuamente exclusivos, para a escolha do tipo de ação: Empréstimo ou Impressão. É uma informação obrigatória.

2. DADOS DA APROVAÇÃO (DA)

Data Aprov. (DA_DATA_APROV) Data da Aprovação. Corresponde à data em que a atividade de aprovação foi realizada. É colocada pelo Ágiles.

Aprovador (DA_APROVADOR) Nome do Aprovador. Corresponde ao nome do executante da atividade de aprovação. É colocado pelo Ágiles.

Botão “Emitir Parecer” (DS_BUTTON_EMITIR_PARECER)

Abre uma janela para que seja feita a aprovação ou reprovação da solicitação. É pedida a senha do aprovador, e existem campos para a escolha do parecer (aprovado ou reprovado) e digitação de comentários. As informações colocadas nesta janela serão exibidas nos próximos 2 campos.

Parecer (DA_PARECER) Exibe o parecer especificado através do botão “Emitir

158

Parecer”. Pode ser: aprovado, reprovado. Não pode ser digitado.

Comentários (DA_COMENTARIOS) Exibe os comentários especificados através do botão “Emitir Parecer”. Não pode ser digitado aqui.

No. Cópia p/ Empréstimo (DA_NUM_COPIA)

Número da Cópia para Empréstimo. Deve ser especificada pelo usuário quando for uma solicitação de empréstimo.

Atenção!!! Caso o processo possua mais que um formulário, a imagem do formulário e

descrição dos campos (conteúdo das 2 páginas acima) deve ser feita para cada

um deles.

159

ObjectType Template

O ObjectType Template é um modelo de representação de um conjunto de informações,

possuindo atributos com tipos variados, sendo eles: boolean, custom, date, item, numeric,

select, text e time. Os Tipos: custom, date, item e select necessitam de um descritivo do tipo.

Como no momento da elaboração dos documentos de análise, os ObjectType Templates

podem não ter sido detalhados ainda (eles serão especificados no documento “IN09 –

Definição dos ObjectType Templates”), especificaremos os objetos necessários para este

processo. Utilize a tabela abaixo como modelo.

Nome Real Nome

exibição

Descrição Tipo Descritivo do

tipo

<nome para

o sistema>

<nome

exibido para o usuário>

<descrição do objeto,

para que serve e como é utilizado>

<define

tipo>

<detalha o tipo

quando necessário>

Exemplo: ObjectType Template br.com.imagetec.PMO.Clientes

Nome Real Nome

exibição

Descrição Tipo Descritivo do

tipo

ID_CLIENT

E

Código do

Cliente

Código do cliente Custo

m

4 dígitos + 2

dígitos [0000 + 00]

END_CLIEN

TE

Endereço Endereço do cliente text -

TEL_CLIEN

TE

Telefone Telefone do cliente Custo

m

2 dígitos + 8

dígitos

[00 + 00000000]

USUARIO_

CLIENTE_PK

Usuários do

Cliente

Relação dos usuários

que são funcionários do cliente

text Usuários do

Ágiles

O ObjectType Template deve ser mencionado no item 8 (descrição das

atividades/tarefas/transições) toda vez que for utilizado, pois neste momento é criada uma

instância do mesmo. Vide exemplo a seguir.

ATIVIDADE 1 (A1) – manual

Nome Solicitar Registro Cliente

Descrição Preencher dados do cliente

Assignees INITIATOR

160

Tasks 1) preencher solicitação de registro de cliente

No formulário (F1):

Divisão 1: Dados da Solicitação

- DS_ID CLIENTE: colocado pelo Ágiles, não pode ser alterado, obrigatório.

- DS_END_CLIENTE: aceita digitação, obrigatório, deve ser colocado pelo usuário.

- DS_USUÁRIO_CLIENTE_PK: campo oculto, colocado pelo Ágiles, não pode ser alterado, obrigatório.

Criar ObjectType Instance (OTI) utilizando br.com.imagetec.PMO.Clientes, com informações: F1:DS_ID_CLIENTE para OTI:ID_CLIENTE; F1:DS_END_CLIENTE para OTI:END_CLIENTE; F1:DS_USUÁRIO_CLIENTE_PK para OTI:USUARIO_CLIENTE_PK.

161

Descrição das Atividades / Tarefas / Transições

Descrição das atividades (com todas suas tarefas) e transições do mapa do processo, contendo

as propriedades que precisam ser definidas no Ágiles, as características e regras dos campos

envolvidos (cite sempre o NOME do campo e não o seu “rótulo”). Vide exemplos abaixo.

ATIVIDADE 1 (A1) – manual

Nome Solicitar Cópia Física

Descrição Preencher solicitação de cópia física, informando se é empréstimo ou impressão de nova cópia.

* Informações: nº da solicitação, solicitante, data da solicitação, documento e tipo de ação.

Assignees INITIATOR

Tasks 1) preencher solicitação de cópia física.

No formulário:

Divisão 1: Dados da Solicitação

- DS_NUM_SOLIC: colocado pelo Ágiles, não pode ser alterado, obrigatório.

- DS_SOLICITANTE: colocado pelo Ágiles, não pode ser alterado, obrigatório.

- DS_DATA_SOLIC: colocado pelo Ágiles, não pode ser alterado, obrigatório.

- DS_DOCUMENTO_NOME: escolhido pelo usuário através do botão “Procurar”, não aceita digitação, obrigatório.

- DS_DOCUMENTO_PK: campo oculto, colocado pelo Ágiles, não pode ser alterado, obrigatório.

- DS_TIPO_ACAO: preenchido pelo usuário, obrigatório.

TRANSIÇÃO 1 (T1)

Nome

Tipo Normal

Condição Identificar Responsáveis pelo documento (todos os que devem receber notificação de que houve uma solicitação para este documento).

ATIVIDADE 2 (A2) – notificação

Nome E-mail para Responsáveis informando solicitação

Descrição Notificar os Responsáveis pelo documento que houve uma solicitação de empréstimo ou impressão deste documento.

To Grupo de usuários identificados na TRANSIÇÃO 1 (T1)

Subject Houve uma solicitação de empréstimo ou impressão de documento

Message Prezado(a) usuário(a),

houve uma solicitação de <DS_TIPO_ACAO> para o documento

162

<DS_DOCUMENTO_NOME>. Ela não exige ação de sua parte, mas como o documento está sob sua responsabilidade, o(a) senhor(a) está sendo notificado.

treinamento em bpm e automação de...

Documents