| | 1 | = ARQUITETURA DE DESENVOLVIMENTO = |
| | 2 | |
| | 3 | O desenvolvimento de processos de Workflow utiliza a arquitetura MVC, já consagrada entre desenvolvedores, que organiza o código em camadas. Cada camada irá limitar-se exclusivamente àquilo que se propõe a fazer, mantendo tudo em seu contexto a fim de tornar transparente a localização de cada parte do código. |
| | 4 | |
| | 5 | [[Image(htdocs:wf/images/mvc.png)]] |
| | 6 | |
| | 7 | == Visão geral == |
| | 8 | |
| | 9 | * O padrão de desenvolvimento MVC do módulo de workflow organiza-se em três níveis: |
| | 10 | |
| | 11 | * módulo: Age em todos os processos desenvolvidos sob o padrão MVC no módulo de workflow. |
| | 12 | |
| | 13 | * processo: Estende o nível de módulo. Age somente sobre as atividades dos processos. |
| | 14 | |
| | 15 | * atividade: Estende os níveis anteriores. Recebe e responde as requisições do usuário final dos processos. |
| | 16 | |
| | 17 | == Camada View == |
| | 18 | |
| | 19 | '''Conceitos:''' |
| | 20 | |
| | 21 | * É toda a interface do sistema, podendo ser tanto para pessoas quanto para outros programas (API). Exemplificando, um sistema pode ter uma interface web e outra web-service em XML. Essa camada deve saber apenas como apresentar os dados gerados pelo sistema; |
| | 22 | |
| | 23 | * Manipulada diretamente apenas pela camada Control, como um de seus atributos; |
| | 24 | |
| | 25 | * Não deve fazer restrições de segurança ou validação de dados, que são funções da camada Model; |
| | 26 | |
| | 27 | * Apresenta interface para interação (entrada de dados) com o usuário; |
| | 28 | |
| | 29 | * Formata e exibe dados vindos da camada Model. |
| | 30 | |
| | 31 | '''Estrutura:''' |
| | 32 | |
| | 33 | * Representada por templates Smarty; |
| | 34 | |
| | 35 | * [http://smarty.php.net/ Site do projeto Smarty]. |
| | 36 | |
| | 37 | == Camada de lógica de negócios (Model) == |
| | 38 | |
| | 39 | '''Conceitos:''' |
| | 40 | |
| | 41 | * A camada Model define o que o processo vai fazer e como implementá-lo, ou seja, as regras de negócio do sistema; |
| | 42 | |
| | 43 | * Possibilita o desenvolvimento de recursos, independentemente da forma como os dados serão exibidos (interface) e do momento em que serão executados (fluxo). Essa camada deve saber somente como executar cada recurso do sistema. |
| | 44 | |
| | 45 | '''Estrutura:''' |
| | 46 | |
| | 47 | * Nível de módulo: |
| | 48 | * Representado pela classe !BaseModel; |
| | 49 | * Contém um atributo para armazenamento de instância da classe Instance (!BaseModel::instance); |
| | 50 | * Contém um atributo para armazenamento de instância da classe Activity (!BaseModel::activity); |
| | 51 | * Contém um atributo para armazenamento de instância da classe Wf_Db (!BaseModel::DAO); |
| | 52 | * Contém um atributo para armazenamento de comandos SQL (!BaseModel::commandText); |
| | 53 | * Contém um atributo para armazenamento de resultados de consultas SQL (!BaseModel::resultSet); |
| | 54 | * Contém um atributo para armazenamento de registros individuais das consultas SQL (!BaseModel::resultRow); |
| | 55 | * Contém um atributo para armazenamento do array $_REQUEST (!BaseModel::request); |
| | 56 | * Contém um atributo para armazenamento de informações sobre o ambiente workflow (!BaseModel::workflow); |
| | 57 | * Contém um atributo para armazenamento de dados a serem lidos pelo Controller e exibidos na View (!BaseModel::viewData); |
| | 58 | * Contém atributos para armazenamento de instâncias de classes de negócio (como paginação); |
| | 59 | * Contém métodos para recuperar e alterar variáveis do ambiente workflow; |
| | 60 | * Contém métodos de sincronização entre as informações contidas na classe Instance e nos atributos; |
| | 61 | * Contém método construtor da camada Model (pode ser estendido no nível de processo). |
| | 62 | |
| | 63 | * Nível de processo: |
| | 64 | * Representado pela classe Model; |
| | 65 | * Contém as informações, representadas na forma de atributos, comuns a todo o processo; |
| | 66 | * Propaga as informações pelas atividades através da sincronização de seus atributos com a classe Instance do módulo de workflow; |
| | 67 | |
| | 68 | * Nível de atividade: |
| | 69 | * Representado pela classe !NomeAtividadeModel; |
| | 70 | * Contém métodos que implementam cada uma das ações solicitadas pelo usuário e encaminhada pelo Controller; |
| | 71 | * Comunica-se com a camada de controle através de seus métodos que retornam booleanos indicando sucesso ou falha na requisição feita pelo usuário. |
| | 72 | |
| | 73 | == Camada de controle (Control) == |
| | 74 | |
| | 75 | '''Conceitos:''' |
| | 76 | |
| | 77 | * Faz o gerenciamento entre o usuário, as Views (interfaces) e o Model (funções do sistema); |
| | 78 | |
| | 79 | * Essa camada deve saber apenas quais são as funções do sistema e não como implementá-las; |
| | 80 | |
| | 81 | * Recebe solicitações de serviços vindas do usuário, chama a implementação do Model correspondente e com base na resposta, encaminha uma interface (View) adequada de volta ao usuário; |
| | 82 | |
| | 83 | * Manipula classe Smarty (ou subclasses dela) para geração da camada de apresentação, que contém formatação de dados; |
| | 84 | |
| | 85 | * Gerencia códigos de erro de acordo com o mapeamento nos arquivos de configuração Smarty. |
| | 86 | |
| | 87 | '''Estrutura:''' |
| | 88 | |
| | 89 | * Nível de módulo: |
| | 90 | * Representado pela classe !BaseController; |
| | 91 | * Contém um atributo para armazenamento de instância da camada View (!BaseController::view); |
| | 92 | * Contém um atributo para controlar qual template (interface) será exibido (!BaseController::templateFile); |
| | 93 | * Contém um atributo para armazenamento de instância Model de atividade (!BaseController::Model); |
| | 94 | * Contém método que recupera os dados produzidos pela camada Model e os envia para a camada View (arquivos tpl, pdf, xml, etc) exibí-los e formatá-los (!BaseController::loadViewVars()); |
| | 95 | * Contém método que cancela a execução da requisição atual (!BaseController::cancelar()); |
| | 96 | * Contém método que executa a ação inicial/padrão de cada atividade, opcional ser vazio e opcional ser sobrescrito (!BaseController::__default()); |
| | 97 | * Contém método abstrato (deve ser sobrescrito) que executa as atividades (!BaseController::run($action)); |
| | 98 | * Contém construtor da camada Controller, recebendo como argumento instância Model de atividade. |
| | 99 | |
| | 100 | * Nível de processo: |
| | 101 | * Representado pela classe Controller; |
| | 102 | * Contém atributos que mapeiam arquivos de templates utilizados. |
| | 103 | |
| | 104 | * Nível de atividade: |
| | 105 | * Representado pela classe !NomeAtividadeController; |
| | 106 | * Gerencia comunicação entre a atividade (sistema) e o usuário; |
| | 107 | * Contém método homônimo para cada uma das ações da atividade; |
| | 108 | * Contém implementação para método herdado run ($action); |
| | 109 | * Contém, quando necessário, implementação para método herdado __default (). |
| | 110 | |
| | 111 | == Arquivo de configuração do processo (shared.php) == |
| | 112 | |
| | 113 | * Responsável por fazer a união das três camadas e possibilitar o mecanismo de extensão das classes base de cada camada. Todos os includes do processo são feitos nesse arquivo; |
| | 114 | |
| | 115 | * Um arquivo de configuração ini (incluído no arquivo shared.php) por processo relacionando as tabelas e campos utilizados com constantes, facilitando a manutenção quando for necessário alterar o nome dos objetos, de forma que a alteração seja feita em um único ponto; |
| | 116 | |
| | 117 | * Definição de constantes do processo. |
| | 118 | |
| | 119 | == Organização de arquivos == |
| | 120 | |
| | 121 | * Uma classe por arquivo .php; |
| | 122 | |
| | 123 | * Includes somente no arquivo shared.php. |
| | 124 | |
| | 125 | == Nomenclatura == |
| | 126 | |
| | 127 | * Atividades: |
| | 128 | * Verbos em português (passar idéia de ação, atividade, comportamento), com a primeira letra maiúscula. Exemplo: Compor, Escrever, Finalizar. |
| | 129 | |
| | 130 | * Arquivos: |
| | 131 | * De atividades: mesmo nome das atividades, adicionando a extensão .php. Exemplo: Compor.php, Escrever.php, Finalizar.php; |
| | 132 | * De templates: mesmo nome das atividades e respectivas ações, adicionando a extensão .tpl. Exemplo: Compor.tpl, Imprimir.tpl, Visualizar.tpl; |
| | 133 | * De classes: segue o formato class.nomeclasse.nomesuperclasse.inc.php. |
| | 134 | |
| | 135 | * Classes: |
| | 136 | * Iniciais com letras maiúsculas. Ex: Classe, !NomeClasse; |
| | 137 | * Subclasses Model seguem o formato [!NomeAtividade]Model; |
| | 138 | * Subclasses Controller seguem o formato [!NomeAtividade]Controller. |
| | 139 | |
| | 140 | * Métodos: |
| | 141 | * Letras minúsculas, caso haja mais de uma palavra, a segunda inicia com letra maiúscula. Ex: metodo, meuMetodo; |
| | 142 | * Métodos de subclasses Model seguem o formato [!NomeAção]Action; |
| | 143 | * Métodos de subclasses Controller têm o mesmo nome das ações das atividades. |
| | 144 | |
| | 145 | == Documentação dos processos == |
| | 146 | |
| | 147 | * Utilização do sistema [wiki:WF/PHPDoc PHPDocumentor] |
| | 148 | |
| | 149 | == Práticas == |
| | 150 | |
| | 151 | * No comentário de elementos como classes ou funções, evitar repetir a classe do elemento na descrição. Por exemplo, no comentário de uma função, evitar incluir a palavra "função". |
| | 152 | |
| | 153 | * Classes com métodos contendo argumentos String esperando valores pré-definidos devem declarar atributos internos escritos em maiúscula para funcionarem como constantes com os valores válidos, visando minimizar erros de digitação do argumento e aproveitar o autocomplete dos editores para membros de classe; |
| | 154 | |
| | 155 | * Deve-se seguir esta sequência de definições em uma classe: |
| | 156 | * Declaração de constantes; |
| | 157 | * Declaração de atributos; |
| | 158 | * Declaração de construtores; |
| | 159 | * Declaração de métodos. |
