Treinamento em BPM e Automação de...
Transcript of Treinamento em BPM e Automação de...
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.
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
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 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.
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 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.
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. 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.
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.
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
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 "finais" 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.
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.
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.
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.
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.
Sincronizado: se essa propriedade estiver “true”, quando for executada, nada mais será executado, não tendo concorrência no processamento.
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
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 "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.
Suas propriedades são:
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).
Bloquear: possibilita o bloqueio da atividade, evitando que ela seja movida (trocada de lugar) por engano, desorganizando o modelo.
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.
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 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.
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.
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).
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.
Prioridade: permite escolher a prioridade dessa atividade no processo. Essa prioridade pode ser mais uma variável a ser utilizada no decorrer do processo.
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.
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.
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 "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.
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.
46
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. 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.
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.
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
Bloquear: possibilita o bloqueio da atividade, evitando que ela seja movida (trocada de lugar) por engano, desorganizando o modelo.
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
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.
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).
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
49
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.
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.
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.
Suas propriedades são:
51
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 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).
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.
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).
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 "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".
Suas propriedades são:
54
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. 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
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.
55
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 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.
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.
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".
Suas propriedades são:
Bloquear: possibilita o bloqueio da atividade, evitando que ela seja movida (trocada de lugar) por engano, desorganizando o modelo.
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.
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.
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.
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.
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.
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".
Obs.: a área cinza, na parte inferior da tela, exibe o conteúdo da propriedade atualmente selecionada.
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"> <!-- Nesse div serão adicinados os campos. Ele deve estar dentro do form --> </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"> <!-- Esse div será copiado. Deve estar fora do form --> <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> <!-- Este bloco de codigo deverá ser implementado pelo desenvolvedor que está criando o formulário.--> <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).
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”
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
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
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.
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 {
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">
...
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
105
public class Solicitacao {
@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
public class Solicitacao {
...
@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)
public class Solicitacao {
...
}
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() {
...
}
}
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;
...
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"?>
<!--DOCTYPE agilesDescriptor SYSTEM "agiles.dtd"-->
<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 {
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() {
...
}
}
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.
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:
Propriedade Descrição Exemplo de preenchimento
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://morpheus-server:389/
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.
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:
Propriedade Descrição Exemplo de preenchimento
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://morpheus-server:389/
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.
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://morpheus-server:389/
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.
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.
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>
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