Changes between Initial Version and Version 1 of WF/camadacontroller

Timestamp:

07/07/08 16:40:57 (16 years ago)

Author:

viani

Comment:

--

WF/camadacontroller

@@ +1 @@
+= Camada de Controle (Control) =
+
+
+
+Por definição, a camada de Controle faz o gerenciamento entre o usuário, as Views (interfaces) e o Model (funções do sistema). Ela 
+deve saber apenas quais são as funções do sistema e não como implementá-las. Será responsável por receber as 
+solicitações de serviços vindas do usuário, chamar a implementação do Model correspondente e com base na resposta, encaminhar uma interface (View) adequada de volta ao usuário.
+
+
+Em hipótese alguma poderá existir formatação de dados nesta camada, bem como não poderão estar implementadas regras do negócio, como por exemplo acesso ao banco de dados.
+
+Exemplo de código de uma camada Controller:
+
+{{{
+<?php
+/**
+ * Gerencia atividade Compor do processo Atos Administrativos.
+ * @author carloseduardo
+ * @author viani
+ * @author aleheil
+ * @version 1.4
+ * @license http://www.gnu.org/copyleft/gpl.html GPL 
+ * @package Atos_Administrativos.
+ */
+class ComporController extends Controller
+{ 
+        /**
+         * Acao padrao/inicial da atividade.
+         * @return void
+         * @access public
+         */
+        function __default ()
+        {               
+                $this->model->defaultAction();
+                $this->loadViewVars();
+                $this->showForm($this->COMPOR);
+        }
+        
+        /**
+         * Executa a ação salvar da atividade compor e encerra a execução da atividade.
+         * @return void
+         * @access public 
+         */
+        function salvar()
+        {               
+                if ( ! $this->model->salvarAction())
+                {
+                        $this->loadViewVars();
+                        $this->showForm($this->COMPOR); 
+                }
+        }    
+        
+        /**
+         * Execucao da atividade.
+         * @param $action Servico (acao) solicitado
+         * @return void
+         * @access private 
+         */ 
+        function run($action)
+        {       
+                $this->model->DAO->connect ( );
+                $this->dispatch($action);
+                $this->model->DAO->disconnect ( );              
+    }
+} 
+?>
+}}}
+
+Neste exemplo, a função run() recebe como parâmetro a ação a ser executada, e o método dispatch() está encarregado de executar a função de controle correspondente. Assim, se for passada a ação 'salvar' será executado o método Salvar() desta mesma classe. Antes disto, porém foi realizada a conexão com o banco de dados, através do comando $this->model->DAO->connect().
+
+Caso nenhuma ação seja recebida, será executado o método !__default(), também definido nesta classe.
+
+Note então que para cada ação que for necessária na atividade, deverá existir uma função correspondente na camada Controller.
+
+Analisando a função Salvar(), vemos que a mesma 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 a ser usado para mostrar os dados.
+
+Tudo que foi falado até aqui sobre a camada Controller diz respeito ao código da atividade, mas note que na definição da classe Controller, existe uma heranca de outra classe, representado pela cláusula 'extends Controller'. Isso significa que existe uma classe superior (pai) da qual a classe em questão herda código. Na classe pai existem métodos que são comuns a todos as classes Controller das atividades. Esta maneira de programar por objetos, com herança, é fundamental para evitar a repetição de código.
+
+Continuando com o exemplo, teremos uma classe Controller, a nível de processo, cujo código está a seguir:
+
+{{{
+<?php
+/**
+ * Gerencia o processo Atos Administrativos
+ * @author carloseduardo
+ * @author viani
+ * @author aleheil
+ * @version 1.4
+ * @license http://www.gnu.org/copyleft/gpl.html GPL 
+ * @package Atos_Administrativos
+ */
+class Controller extends BaseController
+{       
+    /**
+     * @var string Tela inicial da atividade Compor
+     * @access public
+     */
+        var $COMPOR = 'Compor.tpl';
+
+        /**
+     * @var string Tela da atividade Enviar
+     * @access public
+     */
+        var $ENVIAR = 'Enviar.tpl';
+
+        /**
+     * @var string Tela da atividade Consultar
+     * @access public
+     */
+        var $CONSULTAR = 'Consultar.tpl';
+
+        /**
+     * @var string Tela da atividade Alterar
+     * @access public
+     */
+        var $ALTERAR = 'alterar.tpl';
+
+        /**
+     * @var string Tela da atividade Visualizar
+     * @access public
+     */
+        var $VISUALIZAR = 'visualizar.tpl';     
+
+        /**
+     * @var string Tela da atividade Imprimir
+     * @access public
+     */
+        var $IMPRIMIR = 'imprimir.tpl';
+        
+        /**
+     * @var string Tela da atividade Manter Categorias
+     * @access public
+     */
+        var $MANTER = 'Manter_Categorias.tpl';
+
+        /**
+     * Process startup settings
+     * @param object $model Model layer instance for activities business logic
+     * @param array $env MVC environment settings 
+     * @return object
+     * @access protected
+     */ 
+        function Controller(&$model , &$env)
+    {
+        $this->super(&$model , &$env);
+        $this->assign('inbox', $this->model->getWfProperty('wf_workflow_path') . 
+                       SEP . 'index.php?start_tab=0');
+        $this->assign('processes', $this->model->getWfProperty('wf_workflow_path') . 
+                       SEP . 'index.php?start_tab=1');
+        $this->assign('activity_title', 'Atos Administrativos');
+    }           
+}
+?>
+}}}
+
+Na classe de Controle, a nível de processo, representado pelo exemplo anterior, iremos colocar tudo aquilo que for comum ao 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 quem extender a classe.
+
+Mais uma vez observamos a existência de uma cláusula 'extends' que neste caso está extendendo 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 pode ser acessados por qualquer classe que a extenda:
+
+
+
+
+
+'''Estrutura:'''
+
+
+
+  * Nível de módulo:
+
+   * Representado pela classe !BaseController;
+
+   * Contém um atributo para armazenamento de instância da camada View (!BaseController::view);
+
+   * Contém um atributo para controlar qual template (interface) será exibido (!BaseController::templateFile);
+
+   * Contém um atributo para armazenamento de instância Model de atividade (!BaseController::Model);
+
+   * 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());
+
+   * Contém método que cancela a execução da requisição atual (!BaseController::cancelar());
+
+   * Contém método que executa a ação inicial/padrão de cada atividade, opcional ser vazio e opcional ser sobrescrito (!BaseController::__default());
+
+   * Contém método abstrato (deve ser sobrescrito) que executa as atividades (!BaseController::run($action));
+
+   * Contém construtor da camada Controller, recebendo como argumento instância Model de atividade.
+
+
+
+
+  * Nível de atividade:
+
+   * Representado pela classe !NomeAtividadeController;
+
+   * Gerencia comunicação entre a atividade (sistema) e o usuário;
+
+   * Contém método homônimo para cada uma das ações da atividade;
+
+   * Contém implementação para método herdado run ($action);
+
+   * Contém, quando necessário, implementação para método herdado __default ().
+