001:
<?php
002:/**
003: * Arquivo do Controlador principal
004: * @package controlador
005: * @author Jose Berardo
006: * @author Joao Ricardo Bastos (UPDATE)
007: * @version 1.0
008: */
009:
010:/**
011: * Classe controladora principal do framework
012: * 
013: * @package controlador
014: */
015:class Controlador {
016:    
017:    /**
018:     * Instância única do Controlador.
019:     * Implementação do padrão Singleton
020:     *
021:     * @var Controlador $instancia
022:     */
023:    private static $instancia;
024:    
025:    /**
026:     * Qual módulo será carregado.
027:     *
028:     * @var Modulo $modulo
029:     */
030:    private $modulo;
031:    
032:    /**
033:     * Array onde serão registradas diversar informações.
034:     * Implementação do padrão de projeto Registry que sugere um local comum para repositório de informações.
035:     *
036:     * @var array $registro
037:     */
038:    private $registro;
039:    
040:    /**
041:     * Construtor privado do controlador.
042:     *
043:     * Só será executado uma única vez por script.
044:     */
045:    private function __construct() {
046:        $this->registro = array();
047:    }
048:    
049:    /**
050:     * Método que recupera a instância da classe Controlador
051:     *
052:     * @return Controlador
053:     */
054:    public static function getInstancia() {
055:        if (!isset(self::$instancia)) {
056:            self::$instancia = new Controlador();
057:        }
058:        return self::$instancia;
059:    }
060:    
061:    /**
062:     * Método que busca uma informação registrada no controlador
063:     *
064:     * @param string $dado Nome do dado a ser buscado
065:     * @return mixed|boolean
066:     */
067:    public function get($dado) {
068:        if (isset($this->registro[$dado])) {
069:            return $this->registro[$dado];
070:        }
071:        return false;
072:    }
073:    
074:    /**
075:     * Método que registra informação no controlador
076:     *
077:     * @param string $nome
078:     * @param mixed $valor
079:     */
080:    public function set($nome, $valor) {
081:        $this->registro[$nome] = $valor;
082:    }
083:    
084:    /**
085:     * Método que informa se o dado foi ou não registrado no controlador
086:     *
087:     * @param string $dado
088:     * @return boolean
089:     */
090:    public function existe($dado) {
091:        return array_key_exists($dado, $this->registro);
092:    }
093:  
094:    /**
095:     * Método que dá sequência ao processamento do script.
096:     * Deverá chamar a classe do módulo correto
097:     *
098:     * @throws ControleException
099:     */
100:    public function despachar() {
101:    
102:        // Recuperando o módulo
103:        $modulo = $this->_recuperarModulo();
104:        
105:        // Recuperando o método-ação
106:        $metodo = $this->_recuperarAcao($modulo);
107:
108:        // Recuperando os parâmetros
109:        $parametros = $this->_recuperarParametros($metodo);
110:        
111:        // Dando sequência ao script
112:        $acao = $this->registro['acao'];
113:
114:        eval ("\$this->modulo->$acao($parametros);");
115:    }
116:
117:    /**
118:     * Método auxiliar que recupera o módulo requisitado
119:     *
120:     * @return Modulo
121:     */
122:    private function _recuperarModulo() {
123:        $modulo = ucfirst($this->registro['modulo']);
124:        if (class_exists($modulo)) {
125:            
126:            /**
127:             * constante que guardará o nome do controlador que está sendo usado
128:             */
129:            define('CONTROLE', strtolower($modulo));
130:        
131:            /**
132:             * constante que guardará o nome do metodo que está sendo usado
133:             */
134:            if(isset($this->registro["acao"]) && !empty($this->registro["acao"])){
135:                define('METODO', strtolower($this->registro["acao"]));
136:            }else{
137:                define('METODO', 'index');                
138:            }
139:            
140:            $this->modulo = new $modulo();
141:        }else{
142:             throw new ControleException(ControleException::MODULO_INEXISTENTE);
143:        }
144:        return $modulo;
145:    }
146:
147:    /**
148:     * Método auxiliar que recupera uma instância da classe de reflexão ReflectionMethod referente ao  método-ação escolhido.
149:     *
150:     * @throws ControleException
151:     * @param Modulo $modulo
152:     * @return ReflectionMethod
153:     */
154:    private function _recuperarAcao($modulo) {
155:        try {
156:            // Verificando se existe o método-ação na classe encontrada
157:            $rc = new ReflectionClass($modulo);
158:            
159:            // Se não existir, a linha abaixo levantará uma ReflectionException
160:            if(!$this->registro["acao"]){
161:                $this->registro["acao"] = "index";
162:            }
163:            
164:            $metodo = $rc->getMethod($this->registro['acao']);
165:            
166:            // Verificando se o método é visível
167:            if ($metodo->isPublic()) {
168:                return $metodo;
169:            }
170:            // Se não for vísivel, lenvantar ControleException
171:            else {
172:                throw new ControleException(ControleException::ACAO_PROTEGIDA);
173:            }
174:
175:        // Se houver ReflectionException, levantar ControleException
176:        } catch (ReflectionException $ex) {
177:            throw new ControleException(ControleException::ACAO_INEXISTENTE);
178:        }
179:    }
180:
181:    /**
182:     * Método auxiliar que recupera a string dos parâmetros para o self::despachar() poder dar sequência ao script.
183:     *
184:     * @throws ControleException
185:     * @param ReflectionMethod $metodo
186:     * @return string
187:     */
188:    private function _recuperarParametros($metodo) {
189:        if(isset($this->registro['parametros'])){
190:            if($this->registro['parametros'][(count($this->registro['parametros']) - 1)] == ""){
191:                array_pop($this->registro['parametros']);
192:            }
193:        }
194:
195:        $_SESSION['parametrosCananical'] = "";
196:        
197:        // Se o total de parâmetros suprir o número requerido
198://        if(isset($this->registro['parametros'])){
199:            if(@count($this->registro['parametros']) >= $metodo->getNumberOfRequiredParameters()) {
200:                
201:                // Recuperando os parâmetros registrados
202:                $parametros = "'";
203:                if (isset($this->registro['parametros'])) {
204:                    
205:                    $_SESSION['parametrosCananical'] = implode("/", $this->registro['parametros']);
206:                    $parametros .= implode("', '", $this->registro['parametros']);
207:                }
208:                $parametros .= "'"; 
209:                $parametros = str_replace("''", "", $parametros);
210:                
211:                return $parametros;
212:            } else {
213:                throw new ControleException(ControleException::PARAMETROS_INSUFICIENTES);
214:            }
215://        }
216:    }
217:
218:}
219: