Fácil MVC

Exceção Capturada

1 - A classe referente ao módulo requisitado não foi encontrada!

Detalhes da pilha

#0 /home/redetrel/public_html/controlador/Controlador.php(100): Controlador->recuperarModulo() #1 /home/redetrel/public_html/index.php(123): Controlador->despachar() #2 {main}

Exceção gerada no arquivo: /home/redetrel/public_html/controlador/Controlador.php - Na linha: 120

Fonte do arquivo

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:   * 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:   * Método auxiliar que recupera o módulo requisitado
112:   *
113:   * @return Modulo
114:   */
115:  private function recuperarModulo() {
116:    $modulo ucfirst($this->registro['modulo']);
117:    if (class_exists($modulo)) {
118:      $this->modulo = new $modulo();
119:    } else {
120:       throw new ControleException(
121:                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:      if(!$this->registro["acao"]){
141:          $this->registro["acao"] = "index";
142:      }
143:      $metodo $rc->getMethod($this->registro['acao']);
144:      // Verificando se o método é visível
145:      if ($metodo->isPublic()) {
146:        return $metodo;
147:        // Se não for vísivel, lenvantar ControleException
148:      } else {
149:        throw new 
150:        ControleException(ControleException::ACAO_PROTEGIDA);
151:      }
152:      // Se houver ReflectionException, 
153:      // levantar ControleException
154:    } catch (ReflectionException $ex) {
155:      throw new 
156:      ControleException(ControleException::ACAO_INEXISTENTE);
157:    }
158:  }
159:  
160:  /**
161:   * Método auxiliar que recupera a string dos parâmetros
162:   * para o self::despachar() poder dar sequência ao script.
163:   * @throws ControleException
164:   * @param ReflectionMethod $metodo
165:   * @return string
166:   */
167:  private function recuperarParametros($metodo) {
168:     if(isset($this->registro['parametros'])){
169:      if($this->registro['parametros'][(count($this->registro['parametros']) - 1)] == ""){
170:          array_pop($this->registro['parametros']);
171:      }
172:     }
173:
174:    // Se o total de parâmetros suprir o número requerido
175:    if (@count($this->registro['parametros']) >=
176:      $metodo->getNumberOfRequiredParameters()) {
177:      // Recuperando os parâmetros registrados
178:      $parametros "'";
179:      if (isset($this->registro['parametros'])) {
180:        $parametros .= implode("', '"181:                       $this->registro['parametros']);
182:      }
183:      $parametros .= "'"184:      $parametros str_replace("''"""$parametros);
185:        
186:      return $parametros;
187:    } else {
188:      throw new ControleException(
189:            ControleException::PARAMETROS_INSUFICIENTES);
190:    }
191:  }
192:  
193:  /**
194:   * Método utilitario chamado pelo contrutor
195:   * para recuperar os dados $_POST e $_FILES
196:   */
197:  private function capturarDados() {
198:    // Capturando dados de requisições POST
199:    $this->dados $_POST;
200:    // Capturando arquivos enviados
201:    $this->arquivos $_FILES;
202:  }
203:}
204:?>