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