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__);
}
/**
* 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);
}
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);
# -------------------------------------------------------------------
}
/**
* 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);
}
/**
* 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"))));
}
public function __construct()
{
# recuperar os parâmetros da URL
$error = \core\url\Url::parseURL();
include 'admin/error/view/error.php';
}
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
}
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__);
}
