Changes between Version 13 and Version 14 of WF/camadacontroller


Ignore:
Timestamp:
07/08/08 15:44:45 (16 years ago)
Author:
viani
Comment:

--

Legend:

Unmodified
Added
Removed
Modified

  • WF/camadacontroller

    v13 v14  
    55deve saber apenas quais são as funções do sistema e não como implementá-las. Será responsável por receber as ações solicitadas pelo usuário, chamar a implementação da Model correspondente e com base na resposta, encaminhar uma interface (View) adequada de volta ao usuário. 
    66 
    7 No esquema MVC empregado no workflow, a camada de Controle está dividida em três níveis, cada qual com suas responsabilidades, como descrito a seguir: 
     7No esquema MVC, empregado no módulo workflow, a camada de Controle está dividida em três níveis, cada qual implementando parte da solução, como descrito a seguir: 
    88 
    9  * nível módulo: age sobre todos os processos de workflow; 
    10  * nível processo: extende o nível de módulo e age sobre todas as atividades do processo; 
    11  * nível atividade: extende o nível de processo e age somente sobre a atividade; 
     9 * Nível módulo: age sobre todos os processos de workflow; 
     10 * Nível processo: extende o nível de módulo e age sobre todas as atividades do processo; 
     11 * Nível atividade: extende o nível de processo e age somente sobre a atividade. 
    1212 
    13 Começando pelo nível de atividade, deve-se fazer o seguinte para implementá-lo: 
     13Começando pelo nível de módulo, ele é representado pela classe !BaseController, que possui atributos e métodos de uso geral, disponíveis para todas as atividades. A classe não precisa ser codificada porque já está inclusa no pacote de código do módulo workflow. Basta extendê-la. 
     14 
     15Atributos da classe !BaseController: 
     16 
     17 * templateFile: armazena o nome do template em uso pela camada View; 
     18 * view: objeto da classe Smarty que representa a camada View; 
     19 * model: objeto da classe Model da atividade. 
     20 
     21Métodos da classe !BaseController: 
     22 
     23 * showForm: troca o template em uso; 
     24 * syncVars: transfere todos os atributos da camada Model para a Camada View; 
     25 * loadViewVars: recupera os dados produzidos pela camada Model e os transfere para a camada View; 
     26 * assign: define o valor de uma variável da camada View; 
     27 * cancelar: aborta a execução da atividade corrente; 
     28 * dispatch: executa a ação solicitada pelo usuário; 
     29 * !__default: método abstrato a ser redefinido nas classes filhas; 
     30 * run: método abstrato a ser redefinido nas classes filhas. 
     31 
     32Partindo para o nível de processo, ele é representado pela classe Controller, que deve ser implementada pelo desenvolvedor do processo, seguindo estas diretrizes: 
     33 
     34 * Criar um arquivo com o nome class.Controller.inc.php; 
     35 * Armazenar o arquivo no diretório 'code' da estrutura de diretórios do processo; 
     36 * Se preferir editar o arquivo pela interface web, ele fica na aba 'includes' da [wiki:WF/Edicaodecodigo interface de codificação]; 
     37 * Definir uma classe com o nome Controller, e que extenda a classe !BaseController; 
     38 * Definir um ou mais atributos para os templates da atividade; 
     39 * Implementar o método !__default(); 
     40 * Implementar o método run(); 
     41 
     42Eis um exemplo de classe Controller de um processo: 
     43 
     44{{{ 
     45<?php 
     46/** 
     47 * Camada Controller a nível de Processo 
     48 * @author Fulano 
     49 * @version 1.x 
     50 * @license http://www.gnu.org/copyleft/gpl.html GPL  
     51 * @package Nome_do_processo 
     52 */ 
     53class Controller extends BaseController 
     54{        
     55    /** 
     56     * @var string Template padrão da atividade 
     57     * @access public 
     58     */ 
     59        var $TEMPLATEPADRAO = 'template.tpl'; 
     60 
     61    /** 
     62     * Construtor da classe 
     63     * @param object $model Instância da camada Model 
     64     * @param array Configurações do ambiente MVC 
     65     * @return object 
     66     * @access public 
     67     */  
     68    function Controller(&$model , &$env) 
     69    { 
     70        $this->super(&$model , &$env); 
     71    }            
     72 
     73    /** 
     74     * Execucao da atividade. 
     75     * @param $action Servico (acao) solicitado 
     76     * @return void 
     77     * @access public 
     78     */ 
     79    function run($action) 
     80    { 
     81        $this->model->DAO->connect(); 
     82        $this->dispatch($action); 
     83        $this->model->DAO->disconnect(); 
     84    } 
     85     
     86} 
     87?> 
     88}}} 
     89 
     90O acionamento da camada de Controle se dará pela execução do método run(), que por sua vez fará uso do método dispatch(), que analisará a ação requisitada e executará o método de ação adequado. Assim, se for requisitada uma ação 'salvar', será executado o método Salvar(), que deverá estar declarado a nível de atividade. Caso nenhuma ação seja recebida, será executado o método !__default(). 
     91 
     92Neste exemplo, ainda, o método run() estabelece uma conexão com o banco de dados do processo, feita através do comando $this->model->DAO->connect(), mas isto é opcional. 
     93 
     94Continuando, agora é a hora de implementar a classe de Controle a nível de atividade. Para isso fazer o seguinte: 
    1495 
    1596 * Criar um arquivo com formato de nome seguindo o padrão class.!AtividadeController.inc.php; 
    16  * Armazenar o arquivo no diretório 'code' da estrutura de diretórios do processo. Se preferir editar os arquivos de controle pela interface web, eles ficam na aba 'includes' da [wiki:WF/Edicaodecodigo Edição interface de codificação]; 
    17  * Definir uma classe com nome no formato AtividadeController, e que extenda a classe Controller do processo; 
     97 * Armazenar o arquivo no diretório 'code' da estrutura de diretórios do processo; 
     98 * Definir uma classe com nome no formato !AtividadeController, e que extenda a classe Controller do processo; 
    1899 * Implementar um método !__default(); 
    19100 * Implementar um método run(); 
    20101 * Implementar um método para cada ação da atividade. 
    21  
    22 O acionamento da camada de Controle se dará pela execução do método run(); 
    23102 
    24103Exemplo de uma classe Controller de uma atividade: 
    … …  
    48127         
    49128        /** 
    50          * Executa a ação  da atividade compor e encerra a execução da atividade. 
     129         * Executa a ação Acao da atividade 
    51130         * @return void 
    52131         * @access public  
    53132         */ 
    54         function salvar() 
     133        function Acao() 
    55134        {                
    56                 if (!$this->model->salvarAction()) 
     135                if (!$this->model->AcaoAction()) 
    57136                { 
    58137                        $this->loadViewVars(); 
    59                         $this->showForm($this->COMPOR);  
     138                        $this->showForm($this->TEMPLATEPADRAO);  
    60139                } 
    61         }     
     140        } 
    62141}  
    63142?> 
    64143}}} 
    65144 
    66 Neste exemplo, o método run() (declarado na classe Controller) recebe como parâmetro a ação a ser executada, e o método dispatch() está encarregado de executar o método de controle correspondente. Assim, se for passada a ação 'salvar' será executado o método salvar() desta mesma classe. 
     145Note que os métodos run() e !__default() devem ser implementados, seja na classe Controller ou na classe !AtividadeController, dependendo de como o desenvolvedor julgar mais conveniente. 
    67146 
    68 Caso nenhuma ação seja recebida, será executado o método !__default(), também definido nesta classe. 
     147É importante ressaltar que para cada ação da atividade, deverá existir um método correspondente na classe a nivel de atividade. 
    69148 
    70 Note que para cada ação que for necessária na atividade, deverá existir um método correspondente na camada Controller. 
    71  
    72 Analisando o método salvar(), vemos que o mesmo faz uso da camada Model para executar a operação de salvamento (negócio) e caso obtenha sucesso irá carregar os dados na camada View e a seguir definir qual o template será usado para mostrar os dados. 
    73  
    74 Tudo que foi falado até aqui sobre a camada Controller está contido no escopo da atividade, mas note que na definição da classe Controller, existe uma herança de outra classe, representado pela cláusula 'extends Controller'. Isso significa que existe uma classe superior (pai) da qual a classe em questão é filha. Na classe pai existem métodos que são comuns a todos as classes Controller das atividades do processo em questão. Esta maneira de programar por objetos, com herança, é fundamental para evitar a repetição de código. 
    75  
    76 Continuando com o exemplo, teremos uma classe Controller, a nível de processo, cujo código está exemplificado a seguir. Esta classe também fica armazena no diretório 'code', e nome do arquivo deve seguir o formato class.Controller.inc.php 
    77  
    78 {{{ 
    79 <?php 
    80 /** 
    81  * Gerencia o processo Atos Administrativos 
    82  * @author carloseduardo 
    83  * @author viani 
    84  * @author aleheil 
    85  * @version 1.4 
    86  * @license http://www.gnu.org/copyleft/gpl.html GPL  
    87  * @package Atos_Administrativos 
    88  */ 
    89 class Controller extends BaseController 
    90 {        
    91     /** 
    92      * @var string Tela inicial da atividade Compor 
    93      * @access public 
    94      */ 
    95         var $COMPOR = 'Compor.tpl'; 
    96  
    97     /** 
    98      * @var string Tela da atividade Consultar 
    99      * @access public 
    100      */ 
    101         var $CONSULTAR = 'Consultar.tpl'; 
    102  
    103     /** 
    104      * @var string Tela da atividade Alterar 
    105      * @access public 
    106      */ 
    107         var $ALTERAR = 'alterar.tpl'; 
    108  
    109     /** 
    110      * @var string Tela da atividade Visualizar 
    111      * @access public 
    112      */ 
    113         var $VISUALIZAR = 'visualizar.tpl';      
    114  
    115     /** 
    116      * Construtor da classe 
    117      * @param object $model Instância da camada Model 
    118      * @param array Configurações do ambiente MVC 
    119      * @return object 
    120      * @access public 
    121      */  
    122     function Controller(&$model , &$env) 
    123     { 
    124         $this->super(&$model , &$env); 
    125         $this->assign('inbox', $this->model->getWfProperty('wf_workflow_path') .  
    126                        SEP . 'index.php?start_tab=0'); 
    127         $this->assign('processes', $this->model->getWfProperty('wf_workflow_path') .  
    128                        SEP . 'index.php?start_tab=1'); 
    129         $this->assign('activity_title', 'Atos Administrativos'); 
    130     }            
    131  
    132     /** 
    133      * Execucao da atividade. 
    134      * @param $action Servico (acao) solicitado 
    135      * @return void 
    136      * @access public 
    137      */ 
    138     function run($action) 
    139     { 
    140         $this->model->DAO->connect(); 
    141         $this->dispatch($action); 
    142         $this->model->DAO->disconnect(); 
    143     } 
    144      
    145 } 
    146 ?> 
    147 }}} 
    148  
    149 Na classe de Controle, a nível de processo, exemplificada no código anterior, iremos colocar tudo aquilo que for comum às classes Controle das atividades. A classe começa definindo as constantes que representam os templates do processo. Depois implementa o método construtor 'Controller', que no exemplo, está definindo três variáveis da camada View, que ficarão disponíveis para as classes que a estenderem. Também é implementado o método run() que é responsável por chamar o método adequado de cada classe Controller das atividades. Podemos notar que, no exemplo, este método já está estabelecendo uma conexão com o banco de dados do processo (feita através do comando $this->model->DAO->connect()), mas isto é opcional. 
    150  
    151 Mais uma vez observamos a existência de uma cláusula 'extends' que neste caso está estendendo a classe !BaseController. Essa classe está definida a nível de módulo e contém métodos de uso geral para atividades de Controle, que estão disponíveis para as classes filhas. 
    152  
    153 Segue uma explicação dos atributos da classe !BaseController: 
    154  
    155  * view: objeto da classe Smarty que representa a camada View; 
    156  * templateFile: armazena o nome do template em uso pela camada View; 
    157  * model: objeto da classe Model da atividade. 
    158  
    159 Métodos da classe !BaseController: 
    160  
    161  * showForm: troca o template em uso; 
    162  * syncVars: transfere todos os atributos da camada Model para a Camada View; 
    163  * loadViewVars: recupera os dados produzidos pela camada Model e os transfere para a camada View; 
    164  * assign: define o valor de uma variável da camada View; 
    165  * cancelar: aborta a execução da atividade corrente; 
    166  * dispatch: executa a ação solicitada pelo usuário. 
    167  
    168 Resumindo, a implementação da camada Controller de uma atividade estará representada por três classes, com herança entre elas: 
    169  
    170   * !BaseController: age em todos os processos desenvolvidos sob o padrão MVC no módulo de workflow; 
    171   * Controller: estende o nível de módulo. Age somente sobre as atividades dos processos; 
    172   * !AtividadeController: estende os níveis anteriores. Recebe e responde as requisições do usuário final dos processos.                 
     149Analisando o método Acao(), vemos que o mesmo faz uso da camada Model para executar a operação de sistema (acaoAction) e caso obtenha sucesso irá carregar os dados na camada View e a seguir definir qual o template será usado para mostrar os dados.