| 20 | | '''Conceitos:''' |
| 21 | | |
| 22 | | * É 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; |
| 23 | | |
| 24 | | * Manipulada diretamente apenas pela camada Control, como um de seus atributos; |
| 25 | | |
| 26 | | * Não deve fazer restrições de segurança ou validação de dados, que são funções da camada Model; |
| 27 | | |
| 28 | | * Apresenta interface para interação (entrada de dados) com o usuário; |
| 29 | | |
| 30 | | * Formata e exibe dados vindos da camada Model. |
| 31 | | |
| 32 | | '''Estrutura:''' |
| 33 | | |
| 34 | | * Representada por templates Smarty; |
| 35 | | |
| 36 | | * [http://smarty.php.net/ Site do projeto Smarty]. |
| 37 | | |
| 38 | | == Camada de lógica de negócios (Model) == |
| 39 | | |
| 40 | | '''Conceitos:''' |
| 41 | | |
| 42 | | * A camada Model define o que o processo vai fazer e como implementá-lo, ou seja, as regras de negócio do sistema; |
| 43 | | |
| 44 | | * 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. |
| 45 | | |
| 46 | | '''Estrutura:''' |
| 47 | | |
| 48 | | * Nível de módulo: |
| 49 | | * Representado pela classe !BaseModel; |
| 50 | | * Contém um atributo para armazenamento de instância da classe Instance (!BaseModel::instance); |
| 51 | | * Contém um atributo para armazenamento de instância da classe Activity (!BaseModel::activity); |
| 52 | | * Contém um atributo para armazenamento de instância da classe Wf_Db (!BaseModel::DAO); |
| 53 | | * Contém um atributo para armazenamento de comandos SQL (!BaseModel::commandText); |
| 54 | | * Contém um atributo para armazenamento de resultados de consultas SQL (!BaseModel::resultSet); |
| 55 | | * Contém um atributo para armazenamento de registros individuais das consultas SQL (!BaseModel::resultRow); |
| 56 | | * Contém um atributo para armazenamento do array $_REQUEST (!BaseModel::request); |
| 57 | | * Contém um atributo para armazenamento de informações sobre o ambiente workflow (!BaseModel::workflow); |
| 58 | | * Contém um atributo para armazenamento de dados a serem lidos pelo Controller e exibidos na View (!BaseModel::viewData); |
| 59 | | * Contém atributos para armazenamento de instâncias de classes de negócio (como paginação); |
| 60 | | * Contém métodos para recuperar e alterar variáveis do ambiente workflow; |
| 61 | | * Contém métodos de sincronização entre as informações contidas na classe Instance e nos atributos; |
| 62 | | * Contém método construtor da camada Model (pode ser estendido no nível de processo). |
| 63 | | |
| 64 | | * Nível de processo: |
| 65 | | * Representado pela classe Model; |
| 66 | | * Contém as informações, representadas na forma de atributos, comuns a todo o processo; |
| 67 | | * Propaga as informações pelas atividades através da sincronização de seus atributos com a classe Instance do módulo de workflow; |
| 68 | | |
| 69 | | * Nível de atividade: |
| 70 | | * Representado pela classe !NomeAtividadeModel; |
| 71 | | * Contém métodos que implementam cada uma das ações solicitadas pelo usuário e encaminhada pelo Controller; |
| 72 | | * 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. |
| 73 | | |
| 74 | | == Camada de controle (Control) == |
| 75 | | |
| 76 | | '''Conceitos:''' |
| 77 | | |
| 78 | | * Faz o gerenciamento entre o usuário, as Views (interfaces) e o Model (funções do sistema); |
| 79 | | |
| 80 | | * Essa camada deve saber apenas quais são as funções do sistema e não como implementá-las; |
| 81 | | |
| 82 | | * 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; |
| 83 | | |
| 84 | | * Manipula classe Smarty (ou subclasses dela) para geração da camada de apresentação, que contém formatação de dados; |
| 85 | | |
| 86 | | * Gerencia códigos de erro de acordo com o mapeamento nos arquivos de configuração Smarty. |
| 87 | | |
| 88 | | '''Estrutura:''' |
| 89 | | |
| 90 | | * Nível de módulo: |
| 91 | | * Representado pela classe !BaseController; |
| 92 | | * Contém um atributo para armazenamento de instância da camada View (!BaseController::view); |
| 93 | | * Contém um atributo para controlar qual template (interface) será exibido (!BaseController::templateFile); |
| 94 | | * Contém um atributo para armazenamento de instância Model de atividade (!BaseController::Model); |
| 95 | | * 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()); |
| 96 | | * Contém método que cancela a execução da requisição atual (!BaseController::cancelar()); |
| 97 | | * Contém método que executa a ação inicial/padrão de cada atividade, opcional ser vazio e opcional ser sobrescrito (!BaseController::__default()); |
| 98 | | * Contém método abstrato (deve ser sobrescrito) que executa as atividades (!BaseController::run($action)); |
| 99 | | * Contém construtor da camada Controller, recebendo como argumento instância Model de atividade. |
| 100 | | |
| 101 | | * Nível de processo: |
| 102 | | * Representado pela classe Controller; |
| 103 | | * Contém atributos que mapeiam arquivos de templates utilizados. |
| 104 | | |
| 105 | | * Nível de atividade: |
| 106 | | * Representado pela classe !NomeAtividadeController; |
| 107 | | * Gerencia comunicação entre a atividade (sistema) e o usuário; |
| 108 | | * Contém método homônimo para cada uma das ações da atividade; |
| 109 | | * Contém implementação para método herdado run ($action); |
| 110 | | * Contém, quando necessário, implementação para método herdado __default (). |
| 111 | | |
| 112 | | == Arquivo de configuração do processo (shared.php) == |
| 113 | | |
| 114 | | * 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; |
| 115 | | |
| 116 | | * 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; |
| 117 | | |
| 118 | | * Definição de constantes do processo. |
| 119 | | |
| 120 | | == Organização de arquivos == |
| 121 | | |
| 122 | | * Uma classe por arquivo .php; |
| 123 | | |
| 124 | | * Includes somente no arquivo shared.php. |
| 125 | | |
| 126 | | == Nomenclatura == |
| 127 | | |
| 128 | | * Atividades: |
| 129 | | * Verbos em português (passar idéia de ação, atividade, comportamento), com a primeira letra maiúscula. Exemplo: Compor, Escrever, Finalizar. |
| 130 | | |
| 131 | | * Arquivos: |
| 132 | | * De atividades: mesmo nome das atividades, adicionando a extensão .php. Exemplo: Compor.php, Escrever.php, Finalizar.php; |
| 133 | | * De templates: mesmo nome das atividades e respectivas ações, adicionando a extensão .tpl. Exemplo: Compor.tpl, Imprimir.tpl, Visualizar.tpl; |
| 134 | | * De classes: segue o formato class.nomeclasse.nomesuperclasse.inc.php. |
| 135 | | |
| 136 | | * Classes: |
| 137 | | * Iniciais com letras maiúsculas. Ex: Classe, !NomeClasse; |
| 138 | | * Subclasses Model seguem o formato [!NomeAtividade]Model; |
| 139 | | * Subclasses Controller seguem o formato [!NomeAtividade]Controller. |
| 140 | | |
| 141 | | * Métodos: |
| 142 | | * Letras minúsculas, caso haja mais de uma palavra, a segunda inicia com letra maiúscula. Ex: metodo, meuMetodo; |
| 143 | | * Métodos de subclasses Model seguem o formato [!NomeAção]Action; |
| 144 | | * Métodos de subclasses Controller têm o mesmo nome das ações das atividades. |
| 145 | | |
| 146 | | == Documentação dos processos == |
| 147 | | |
| 148 | | * Utilização do sistema [wiki:WF/PHPDoc PHPDocumentor] |
| 149 | | |
| 150 | | == Práticas == |
| 151 | | |
| 152 | | * 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". |
| 153 | | |
| 154 | | * 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; |
| 155 | | |
| 156 | | * Deve-se seguir esta sequência de definições em uma classe: |
| 157 | | * Declaração de constantes; |
| 158 | | * Declaração de atributos; |
| 159 | | * Declaração de construtores; |
| 160 | | * Declaração de métodos. |
| | 26 | Assim fecha-se o ciclo e a atividade fica no aguardo de uma ação do usuário para novamente acionar a camada Controller. |
