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