Esempio n. 1
0
 public function gantt()
 {
     //$res=mysql_connect("localhost","root","312487");
     $res = mysqli_connect("localhost", "root", "312487", "huab");
     $url = Url::parseURL();
     $oCon = new \core\dba\pdo\Conexao(DRIVER, HOST, DBNAME, USERNAME, PASSWD);
     //$oAgenda = new \app\models\Agenda();
     //$pAgenda = new \app\models\AgendaPersist($oCon, $oAgenda);
     //mysql_select_db("gantt");
     include "public/lib/dhtmlxScheduler_v4.3.1/codebase/connector/gantt_connector.php";
     $gantt->render_links("gantt_links", "id", "source,target,type");
     $gantt->render_table("gantt_tasks", "id", "start_date,duration,text,progress,sortorder,parent");
     include_once $this->_include(__CLASS__, __METHOD__);
 }
Esempio n. 2
0
 /**
  * Método responsável pela instância do controlador
  * associado a uma deterinada rota. Todo controlador
  * recebe como parâmetro uma action, que é o gatilho
  * para determinar o método do controlador dará
  * tratamento da requisição.
  * @param array $route
  */
 public function run(array $route)
 {
     if (key_exists('action', $route)) {
         $action = $route['action'];
     } elseif (key_exists('a', Url::parseURL())) {
         $a = Url::parseURL();
         $action = $a['a'];
     } else {
         $action = null;
     }
     # define o namespace do controlador
     $Controller = '\\admin\\controllers\\' . ucfirst($route['controller']);
     # cria uma instância do controlador
     new $Controller($action);
 }
Esempio n. 3
0
 public function __construct()
 {
     session_start();
     $this->charset();
     $this->timezone();
     $this->set_time_limit();
     $this->displayerrors($_SERVER['SERVER_NAME']);
     # Definição do diretório de instalação
     define("BASEDIR", dirname(__FILE__));
     # -------------------------------------------------------------------
     # TRATAMENTO DA URL DA APLICAÇÃO
     # Definição da URL base do sistema
     define("BASEURL", Url::urlBase());
     # Definir o tipo de URL do sistema
     Url::setTipoURL(2);
     # 1 - URL padrão; 2 - URL amigável; 3 - URL criptografada
     # Analisar e recuperar os elementos da URL
     $parseUrl = Url::parseURL();
     # -------------------------------------------------------------------
     /* SEGURANÇA
      * Variável para controle de acesso aos scripts do projeto.
      * Os scritps devem ser acessados apenas pela index, caso 
      * contrário devem ser bloqueados.
      */
     define("ACESSO", true);
     # -------------------------------------------------------------------
     # INCLUSÃO DOS CONTROLADORES DA APLICAÇÃO
     /*
      * A classe bootstrap inicializa as rotas da aplicação, as rotas contém
      * o diretório e o inicializador (Init) a ser instanciado. Os diretórios
      * app e admin possuem uma classe Init que gerenciam o acesso aos controladores
      * 
      * A classe Bootstrap recebe como parâmetro o módulo da aplicação e 
      * através deste seleciona a rota "app" ou "admin".
      */
     $bootstrap = new Bootstrap(new AppRoute(), $parseUrl['m']);
     # $route: retorna um array de dados: Ex Array ( [route] => app [controller] => Index [action] => home )
     $route = $bootstrap->getRoute();
     # define o caminho da classe a ser instanciada. Ex: \\app\\Init ou \\admin\\Init
     # $route['route'] recupera a rota "app" ou "admin"
     $Init = '\\' . $route['route'] . '\\Init';
     # Instância do controlador Init. Ex: new app/Init( array $route );
     # app/Init ou admin/Init
     new $Init($route);
     # -------------------------------------------------------------------
 }
Esempio n. 4
0
 /**
  * Método responsável pela instância do controlador
  * associado a uma deterinada rota. Todo controlador
  * recebe como parâmetro uma action, que é o gatilho
  * para determinar o método do controlador dará
  * tratamento da requisição.
  * @param array $route
  */
 public function run(array $route)
 {
     # Definir qual ação (action) deverá ser executada.
     # Uma action é um método do controlador.
     if (key_exists('action', $route)) {
         $action = $route['action'];
     } elseif (key_exists('a', Url::parseURL())) {
         $a = Url::parseURL();
         $action = $a['a'];
     } else {
         $action = null;
     }
     # define o namespace do controlador
     //$Controller = '\\admin\\controllers\\'.ucfirst($route['controller']);
     # define o namespace do controlador
     $Controller = '\\admin\\' . $route['module'] . '\\' . ucfirst($route['controller']);
     # cria uma instância do controlador e passa como parâmetro a método a ser chamado
     new $Controller($action);
 }
Esempio n. 5
0
 /**
  * Método responsável pela instância do controlador
  * associado a uma deterinada rota. Todo controlador
  * recebe como parâmetro uma action, que é o gatilho
  * para determinar o método do controlador dará
  * tratamento da requisição.
  * @param array $route
  */
 public function run(array $route)
 {
     # recupera o action da tabela de rotas
     /* Recupera o action definido na tabela de rotas, essa tabela
      * tem precedência sobre o URL, pois são mutuamente exclusivas.
      */
     if (key_exists('action', $route)) {
         # recupera o action definido na rota da aplicação: Array ( [route] => app [controller] => Index [action] => home )
         $action = $route['action'];
     } elseif (key_exists('a', Url::parseURL())) {
         #pode apresentar problemas em múltiplas instâncias?? classe estática!!
         $a = Url::parseURL();
         $action = $a['a'];
     } else {
         $action = null;
     }
     # define o namespace do controlador
     $Controller = '\\app\\' . $route['module'] . '\\' . ucfirst($route['controller']);
     # cria uma instância do controlador e passa como parâmetro o action da aplicação (método)
     new $Controller($action);
 }
 /**
  * Esse método foi substituido pelo pelo add e emcapsulado pelo save na classe
  * Generic controler.
  * MANTER APENAS PARA POSSIVEIS CONSULTAS
  */
 private function saveCliente()
 {
     # -- debug do método POST
     # debug(__FILE__, __LINE__, $_POST);
     # Recuperar parâmetors da URL
     $url = \core\url\Url::parseURL();
     # Instância do novo objeto
     $objPrincipal = new \app\teste\models\Cliente();
     # Documentação da classe
     $docObjPrincipal = new \core\orm\PHPDoc(get_class($objPrincipal));
     # array de atributos da classe principal
     # Ex: array(idCliente, nome, data_nascimento, idSituacao)
     $atributos = $docObjPrincipal->getProperties()[get_class($objPrincipal)];
     # Carga dos atributos da classe Principal (sem validação)
     foreach ($atributos as $atributo) {
         $objPrincipal->__set($atributo, $_POST['cliente'][$atributo]);
     }
     /**
      * @TODO como controlar falhas AQUI!!!!!!!!!!!!!!!!!
      */
     $objPrincipal->save();
     # ------------------------------------------------------------------
     # CLASSES DERIVADAS
     # Array com atributos da classe principal e referência as classes derivadas
     $arrayClassesDerivadas = $docObjPrincipal->getProperties();
     # Exclusão das propriedades da classe principal
     unset($arrayClassesDerivadas[get_class($objPrincipal)]);
     # grupo: contém referência ao nome da classe Ex: telefone  (class Telefone)
     # classeDerivada: contém o nome qualificado da classe derivada Ex: namespace/Classe
     foreach ($arrayClassesDerivadas as $classeDerivada => $grupo) {
         # Array de dados oriundos do formulário html
         # Value: array atributo = valor da classe derivada
         foreach ($_POST[$grupo] as $key => $value) {
             # Cria uma instância da classe
             $objDerivado = new $classeDerivada();
             # Recupera a documentação da classe
             $docObjDerivado = new \core\orm\PHPDoc($classeDerivada);
             # Recupera um array com os atributos da classe derivada
             $arrayAttrClasseDerivada = $docObjDerivado->getProperties()[$classeDerivada];
             # Verificar se o objeto já existe
             # Se $key estiver no array $arrayAttrClasseDerivada, o objeto deverá ser criado.
             if (in_array($key, $arrayAttrClasseDerivada)) {
                 # agrupar por características e alimentar a classe.
                 /* formato do array
                        telefone => Array(  1 => Array (idTelefone => 1, ddd => 84, telefone => 999263571),
                                            5 => Array (idTelefone => 1, ddd => 84, telefone => 981565525),
                                            ddd => Array (0 => 55, 1 => 53),
                                            telefone => Array (0 => 111111111, 1 => 2222222222 ));
                    */
                 # Forma um array com os dados novos VER: TRATAMENTO DE ARRAY DE NOVOS DADOS
                 foreach ($value as $kValue => $vValue) {
                     $aDados[$grupo][$kValue][$key] = $vValue;
                 }
             } else {
                 # Se $key não estiver no array $arrayAttrClasseDerivada, o objeto já existe
                 foreach ($arrayAttrClasseDerivada as $attrClasseDerivada) {
                     # Se a clausula if for acionada, os dados já existem
                     if (key_exists($attrClasseDerivada, $value)) {
                         $objDerivado->__set($attrClasseDerivada, $value[$attrClasseDerivada]);
                     }
                 }
                 $objDerivado->__set($docObjPrincipal->getPK(), $objPrincipal->__get($docObjPrincipal->getPK()));
                 /**
                  * @TODO como controlar falhas AQUI!!!!!!!!!!!!!!!!!
                  */
                 $objDerivado->save();
             }
         }
     }
     unset($nomeClasseSimples);
     # --------------------------------------------------------
     # TRATAMENTO DO ARRAY DE NOVOS DADOS
     # --------------------------------------------------------
     foreach ($arrayClassesDerivadas as $namespaceClass => $atributoReferenciado) {
         if (key_exists($atributoReferenciado, $aDados)) {
             foreach ($aDados[$atributoReferenciado] as $kDados => $vDados) {
                 # debug( __FILE__, __LINE__, $namespaceClass );
                 # Cria uma instância da classe
                 $objDerivado2 = new $namespaceClass();
                 # Recupera a documentação da classe
                 $docObjDerivado2 = new \core\orm\PHPDoc($namespaceClass);
                 # Recupera um array com os atributos da classe derivada
                 $arrayAttrClasseDerivada2 = $docObjDerivado2->getProperties()[$namespaceClass];
                 foreach ($vDados as $kvDados => $vvDados) {
                     if (in_array($kvDados, $arrayAttrClasseDerivada2)) {
                         $objDerivado2->__set($kvDados, $vvDados);
                     }
                 }
                 $objDerivado2->__set($docObjPrincipal->getPK(), $objPrincipal->__get($docObjPrincipal->getPK()));
                 /**
                  * @TODO como controlar falhas AQUI!!!!!!!!!!!!!!!!!
                  */
                 //$objDerivado2->save();
             }
         }
     }
     header("location: " . \core\url\Url::setURL("teste", "edt", array($objPrincipal->__get("idCliente"), $objPrincipal->__get("nome"))));
 }
Esempio n. 7
0
 public function __construct()
 {
     # recuperar os parâmetros da URL
     $error = \core\url\Url::parseURL();
     include 'admin/error/view/error.php';
 }
Esempio n. 8
0
 private function save()
 {
     # recuperar os parâmetros da URL
     $tabela = \core\url\Url::parseURL();
     # -----------------------------------------------------------------
     # RECUPERAR OS METADADOS DA TABELA
     $oMetaDadosTabela = new \admin\tabelas\models\Tabelas(new \core\dba\pdo\Conexao(DRIVER, HOST, "information_schema", USERNAME, PASSWD));
     $metaDadosTabela = $oMetaDadosTabela->getMetaDataTable($tabela['table'], DRIVER);
     # identificar a chave primária
     foreach ($metaDadosTabela as $key => $metadados) {
         # armazena o nome das colunas da tabela
         $column_name[] = $metadados['column_name'];
         if ($metadados['column_key'] == 'PRI') {
             $primary_key = $metadados['column_name'];
         }
     }
     # -----------------------------------------------------------------
     # de column_name = array(column1,column2) --> para column_name = array(column1 => 0, column2 = 1)
     $column_name = array_flip($column_name);
     # verifica se os nomes dos campos, oriundos do formuláro html
     # são os mesmos nomes contidos nos metadados da tabela (column_name)
     # se não existir, será excluído do POST
     foreach (array_keys($_POST) as $value) {
         if (!array_key_exists($value, $column_name)) {
             unset($_POST[$value]);
         }
     }
     $oRegistroTabela = new \admin\tabelas\models\Tabelas(new \core\dba\pdo\Conexao(DRIVER, HOST, DBNAME, USERNAME, PASSWD));
     $oRegistroTabela->setRegistroTabela($tabela['table'], $primary_key, $_POST);
     $this->edt();
     # 1 - Recuperar o nome da tabela
     # 2 - se houver id definido, realizar update
     # 2.1 - se o id for nulo, realizar insert
     # 2.1.2 - recuperar o id gerado pela aplicação
     # 3 - redirecionar para o método edt
 }
Esempio n. 9
0
 public function lista()
 {
     $url = Url::parseURL();
     $oCon = new \core\dba\pdo\Conexao(DRIVER, HOST, DBNAME, USERNAME, PASSWD);
     $oPop = new \app\models\Pop();
     $pPop = new \app\models\PopPersist($oCon, $oPop);
     include_once $this->_include(__CLASS__, __METHOD__);
 }