Omar, não sei como usar a classe Select (para filtrar), Update e Delete do seu projeto
arquivo /omar2/controles/controle.php
<?php
class controle {
public function consultar(){
$select=new Select;
$select->query('usuários');
$teste=$select->result();
var_dump($teste);
$this->voltar();}
public function filtrar(){
$select=new Select;
$select->genérico("select * from usuários where nome like 'frank%'");
$teste=$select->result();
var_dump($teste);
$this->voltar();}
public function adicionar(){
$insert=new Insert();
$insert->query("usuários",["id"=>3,"nome"=>"teste","email"=>"teste@uol.com.br","senha"=>"JamesBond"]);
$teste=$insert->error();
var_dump($teste);
$this->voltar();}
public function atualizar(){
$update=new Update();
$update->genérico('update usuários set nome="outro teste" where id=3');
$teste=$update->error();
var_dump($teste);
$this->voltar();}
public function excluir(){
$delete=new Delete();
$delete->genérico('delete from usuários where id=3');
$teste=$delete->error();
var_dump($teste);
$this->voltar();}
public function voltar(){
echo "<input type=submit value=Voltar onclick=location.replace('index.php')>";
exit;}}
$controle=new controle();
if(isset($_GET)){
$get=$_GET;
if(empty($get)){return;}
if($get['url']=="consultar"){$controle->consultar();}
if($get['url']=="filtrar"){$controle->filtrar();}}
if($get['url']=="adicionar"){$controle->adicionar();}
if($get['url']=="atualizar"){$controle->atualizar();}
if($get['url']=="excluir"){$controle->excluir();}arquivo /omar2/index.php
<?php
require 'visões/index.php';arquivo /omar2/modelos/Connect.php
<?php
class Connect {
private static $host = DB_HOST;
private static $user = DB_USER;
private static $pass = DB_PASS;
private static $data = DB_DATA;
private static $isConnect = null;
private static $isError = null;
private static function makeConnect() {
try {
if (self::$isConnect == null) {
$dsn = 'mysql:host=' . self::$host . '; dbname=' . self::$data;
$options = [PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES UTF8'];
self::$isConnect = new PDO($dsn, self::$user, self::$pass, $options); }
} catch (PDOException $e) {
self::$isError = '<br>Não foi possível conectar com o banco de dados!<br> Descrição:' . $e->getMessage() . '<br>';
//die('Erro interno no servidor. Código de referência 500');
die($e->getMessage()); }
self::$isConnect->SetAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
return (self::$isConnect); }
protected static function callConnect() {
return (self::makeConnect()); }
protected static function getError() {
if (self::$isError) {
return (self::$isError);}}}arquivo /omar2/modelos/Delete.php
<?php
class Delete extends Connect {
private $deleteTable;
private $deleteFields;
private $deleteValues;
private $deleteSyntax;
private $deleteConn;
private $deleteData;
private $deleteError;
public function genérico($deletar){
$this->deleteSyntax=$deletar;
$this->deleteExecute();}
public function query($table, $fields, $statements) {
$this->deleteTable = (string) $table;
$this->deleteFields = (string) $fields;
parse_str($statements, $this->deleteValues);
$this->deleteConstruct();
$this->deleteExecute(); }
public function count() {
if ($this->deleteData) {
return ($this->deleteSyntax->rowCount());} else {
return (0);}}
public function result() {
if ($this->deleteData) {
return ($this->deleteData);}}
public function error() {
if (!$this->deleteData) {
return ($this->deleteError);}}
private function deleteConstruct() {
$this->deleteSyntax = "DELETE FROM {$this->deleteTable} WHERE {$this->deleteFields}";}
private function deleteConnect() {
$this->deleteConn = parent::callConnect();
$this->deleteSyntax = $this->deleteConn->prepare($this->deleteSyntax);}
private function deleteExecute() {
$this->deleteConnect();
try {
$this->deleteSyntax->execute($this->deleteValues);
$this->deleteData = true;
} catch (PDOException $error) {
$this->deleteData = null;
$this->deleteError = "Erro ao ler dados: {$error->getMessage()} {$error->getCode()}";}}}arquivo /omar2/modelos/GlobalFilter.php
<?php
class GlobalFilter {
public static function StdArray($array) {
$object = new stdClass();
if (is_array($array)) {
foreach ($array as $name => $value) {
$object->$name = $value;}}
return $object;}
public static function ObjArray($array) {
if (is_array($array)) {
//return (object) array_map(__FUNCTION__, $array);
return (object) array_map(__METHOD__, $array);} else {
return $array;}}
public static function filterGet() {
$filterGet = filter_input_array(INPUT_GET, FILTER_DEFAULT);
$filter = isset($filterGet) ? self::StdArray($filterGet) : false;
return ($filter);}
public static function filterPost() {
$filterPost = filter_input_array(INPUT_POST, FILTER_DEFAULT);
$filter = isset($filterPost) ? self::StdArray($filterPost) : false;
return ($filter);}
public static function filterSession() {
$filterSession = filter_input_array(INPUT_SESSION, FILTER_DEFAULT);
$filter = isset($filterSession) ? self::StdArray($filterSession) : false;
return ($filter);}
public static function filterCookie() {
$filterCookie = filter_input_array(INPUT_COOKIE, FILTER_DEFAULT);
$filter = isset($filterCookie) ? self::StdArray($filterCookie) : false;
return ($filter);}
public static function filterServe() {
$filterServe = filter_input_array(INPUT_SERVER, FILTER_DEFAULT);
$filter = isset($filterServe) ? self::StdArray($filterServe) : false;
return ($filter);}
public static function filterEven() {
$filterEven = filter_input_array(INPUT_ENV, FILTER_DEFAULT);
$filter = isset($filterEven) ? self::StdArray($filterEven) : false;
return ($filter);}
public static function filterRequest() {
$filterRequest = filter_input_array(INPUT_REQUEST, FILTER_DEFAULT);
$filter = isset($filterRequest) ? self::StdArray($filterRequest) : false;
return ($filter);}}arquivo /omar2/modelos/Insert.php
<?php
class Insert extends Connect {
private $insertTable;
private $insertFilds;
private $insertSyntax;
private $insertConn;
private $insertData;
private $insertError;
public function query($table, array $fields) {
$this->insertTable = (string) $table;
$this->insertFilds = $fields;
$this->insertConstruct();
$this->insertExecute(); }
public function count() {
if ($this->insertData) {
return ($this->insertSyntax->rowCount());} else {
return (0);}}
public function result() {
if ($this->insertData) {
return ($this->insertData);}}
public function error() {
if (!empty($this->insertError)) {
return ($this->insertError);}}
private function insertConstruct() {
$Column = implode(', ', array_keys($this->insertFilds));
$values = ':' . implode(', :', array_keys($this->insertFilds));
$this->insertSyntax = "INSERT INTO {$this->insertTable} ({$Column}) VALUES ({$values})";}
private function insertConnect() {
$this->insertConn = parent::callConnect();
$this->insertSyntax = $this->insertConn->prepare($this->insertSyntax);}
private function insertExecute() {
$this->insertConnect();
try {
$this->insertSyntax->execute($this->insertFilds);
$this->insertData = $this->insertConn->lastInsertId();
} catch (PDOException $error) {
$this->insertData = null;
$this->insertError = "Erro ao inserir dados: {$error->getMessage()} {$error->getCode()}";}}}arquivo /omar2/modelos/LogRegister.php
<?php
class LogRegister {
private static $file;
private static $message;
private static $comment;
public static function dataError($file, $message, $comment = null) {
self::$file = (string) $file;
self::$message = (string) $message;
self::$comment = (string) $comment;
if (!empty($file) && !empty($message)) {
self::registerError();}}
private static function registerError() {
$lgErr = new Select();
$lgErr->query('log_error', [
'lg_date' => date('Y-m-d'),
'lg_hour' => date('H:i:s'),
'lg_file' => self::$file,
'lg_message' => htmlentities(self::$message),
'lg_comment' => htmlentities(self::$comment)]);
if ($lgErr->error()) {
self::sqlError();}}
private static function sqlError() {
$txt = "== [ ERROR ] ===========================\n"
. "- Data: " . date('Y-m-d') . "\n"
. "- Horário: " . date('H:i:s') . "\n"
. "- Arquivo: " . self::$file . "\n"
. (!empty(self::$message) ? "- Mensagem:\n" . strip_tags(self::$message) . "\n" : "")
. (!empty(self::$comment) ? "\n- Comentários:\n" . strip_tags(self::$comment) : "")
. "\n";
$reg = fopen(MODELO_DIR . 'error.log', 'a');
fwrite($reg, $txt);
fclose($reg);}}
arquivo /omar2/modelos/Select.php
<?php
class Select extends Connect {
private $selectTable;
private $selectFields;
private $selectSyntax;
private $selectConn;
private $selectData;
private $selectError;
public function genérico($consulta){
$this->selectTable=$consulta;
$this->selectExecute();}
public function query($table, $fields = null, $statements = null) {
if (!empty($statements)) {
parse_str($statements, $this->selectFields);}
$this->selectTable = 'SELECT * FROM ' . $table . (isset($fields) ? ' WHERE ' . $fields : null);
$this->selectExecute();}
public function setQuery($Query, $statements = null) {
if (!empty($statements)) {
parse_str($statements, $this->selectFields); }
$this->selectTable = (string) $Query;
$this->selectExecute(); }
public function count() {
return ($this->selectSyntax->rowCount());}
public function result() {
if ($this->selectData) {
return ($this->selectData);}}
public function error() {
if (!empty($this->selectError)) {
return ($this->selectError);}}
private function selectConstruct() {
if ($this->selectFields) {
foreach ($this->selectFields as $type => $value) {
if ($type == 'limit' || $type == 'offset') {
$value = (int) $value;}
$this->selectSyntax->bindValue(":{$type}", $value, (is_int($value) ?
PDO::PARAM_INT : PDO::PARAM_STR));}}}
private function selectConnect() {
$this->selectConn = parent::callConnect();
$this->selectSyntax = $this->selectConn->prepare($this->selectTable);
$this->selectSyntax->setFetchMode(PDO::FETCH_OBJ);}
private function selectExecute() {
$this->selectConnect();
try {
$this->selectConstruct();
$this->selectSyntax->execute();
$this->selectData = $this->selectSyntax->fetchAll();
} catch (PDOException $error) {
$this->selectData = null;
$this->selectError = "Erro ao ler dados: {$error->getMessage()} {$error->getCode()}";}}}arquivo /omar2/modelos/Session.php
<?php
class Session {
private static $status;
private static $globalName;
private static $session;
public static function startSession($prefix = null) {
self::$globalName = (empty($prefix) ? null : '_' . $prefix);
if (!self::$status) {
self::$session = new self; }
self::$status = session_start();
return (self::$session);}
public static function getSession() {
return (self::$status);}
public static function destroy() {
self::$session = session_destroy();
unset($_SESSION);}
public function __set($name, $value) {
$_SESSION[$name . self::$globalName] = $value;}
public function __get($name) {
if (isset($_SESSION[$name . self::$globalName])) {
return ($_SESSION[$name . self::$globalName]);}}
public function __isset($name) {
return (isset($_SESSION[$name . self::$globalName]));}
public function __unset($name) {
unset($_SESSION[$name . self::$globalName]);}}
arquivo /omar2/modelos/Update.php
<?php
class Update extends Connect {
private $updateTable;
private $updateColumn = [];
private $updateFields;
private $updateValues = [];
private $updateSyntax;
private $updateConn;
private $updateError;
private $updateData;
public function genérico($atualização){
$this->updateSyntax=$atualização;
$this->updateExecute($atualização);}
public function query($table, array $change, $target, $statements) {
$this->updateTable = (string) $table;
$this->updateColumn = $change;
$this->updateFields = (string) $target;
parse_str($statements, $this->updateValues);
$this->updateConstruct();
$this->updateExecute();}
public function setQuery($query, $statements = null) {
if (!empty($statements)) {
parse_str($statements, $this->updateValues); }
$this->updateSyntax = $query;
$this->updateExecute();}
public function count() {
if ($this->updateData) {
return ($this->updateSyntax->rowCount());} else {
return (0);}}
public function error() {
if (!empty($this->updateError)) {
return ($this->updateError);}}
private function updateConstruct() {
foreach ($this->updateColumn as $Key => $Value) {
$setKey[] = $Key . ' = :' . $Key;}
$Value = array();
$setKey = implode(', ', $setKey);
$this->updateSyntax = "UPDATE {$this->updateTable} SET {$setKey} WHERE {$this->updateFields}";}
private function updateConnect() {
$this->updateConn = parent::callConnect();
$this->updateSyntax = $this->updateConn->prepare($this->updateSyntax);}
private function updateExecute() {
$this->updateConnect();
try {
$this->updateSyntax->execute(array_merge($this->updateColumn, $this->updateValues));
$this->updateData = true;
} catch (PDOException $error) {
$this->updateData = false;
$this->updateError = "Erro ao alterar dados: {$error->getMessage()} {$error->getCode()}";}}}arquivo /omar2/modelos/config.php
<?php
error_reporting(E_ALL);
ini_set('ignore_repeated_errors', TRUE);
ini_set('display_errors', TRUE);
ini_set('log_errors', TRUE);
ini_set('error_log', __DIR__ . '/error.log');
ob_start();
defined('MODELO_DIR') || define('MODELO_DIR',$_SERVER['DOCUMENT_ROOT'] .'/omar2/modelos/');
defined('CONTROLE_DIR') || define('CONTROLE_DIR',$_SERVER['DOCUMENT_ROOT'].'/omar2/controles/');$con = [
'ready' => true,
'dbHost' => 'localhost',
'dbUser' => 'root',
'dbPass' => '',
'dbName' => 'mvc'];$setting = [
'ready' => true,
'siteName' => 'Meu website',
'charset' => 'UTF-8'];try {
if (!isset($con['ready'])) {
throw new Exception('Dados de configurações para conexão não definidos', E_ERROR);
} else if (!isset($setting['ready'])) {
throw new Exception('Dados de configurações de comportamento não definidos', E_ERROR);
} else {
defined('DB_HOST') || define('DB_HOST', $con['dbHost']);
defined('DB_USER') || define('DB_USER', $con['dbUser']);
defined('DB_PASS') || define('DB_PASS', $con['dbPass']);
defined('DB_DATA') || define('DB_DATA', $con['dbName']);
defined('SITE_NAME') || define('SITE_NAME', $setting['siteName']);
date_default_timezone_set('America/Sao_Paulo');
spl_autoload_register(function ($class) {
$includeDir = false;
$findDir = ['controles','modelos','visões'];
foreach ($findDir as $DirName) {
if (!$includeDir
&& file_exists(FindClass($DirName, $class))
&& !is_dir(FindClass($DirName, $class))) {
include_once (FindClass($DirName, $class));
$includeDir = true;}}
if (!$includeDir) {
die("Erro interno no servidor ao encontrar dados cruciais de funcionamento!");}});
function FindClass($dir, $class) {
return (
$_SERVER['DOCUMENT_ROOT']
. DIRECTORY_SEPARATOR . 'omar2'
. DIRECTORY_SEPARATOR . $dir
. DIRECTORY_SEPARATOR . $class . '.php');}
$session = Session::startSession(SITE_NAME);
$config = GlobalFilter::ObjArray($setting);}}
catch (Exception $e) {header('location : http500/');}arquivo /omar2/visões/index.php
<!DOCTYPE html>
<html>
<head>
<?php
require $_SERVER['DOCUMENT_ROOT']."/omar2/modelos/config.php";
$serve = filter_input_array(INPUT_SERVER, FILTER_DEFAULT);
$rootUrl = strlen($serve['DOCUMENT_ROOT']);
$fileUrl = substr($serve['SCRIPT_FILENAME'], $rootUrl, -9);
if ($fileUrl[0] == '/') {$baseUri = $fileUrl;} else {
$baseUri = '/' . $fileUrl;} ?>
<base href="<?= $baseUri ?>" />
<meta charset="<?=$setting['charset']?>" />
<title><?= SITE_NAME ?></title>
</head>
<body>
<?php
$filter = filter_input(INPUT_GET, 'url', FILTER_DEFAULT);
$setUrl = empty($filter) ? 'consultar' : $filter;
$explode = explode('/', $setUrl);
$url = array_filter($explode);
$request=$url[0];
$map = ['consultar','filtrar','adicionar','atualizar','excluir'];
$file = false;
foreach ($map as $value) {
if (($request == $value) || (is_array($value) && in_array($request, $value))) {
$opção = $value; break; }}
if ($opção) {require CONTROLE_DIR."controle.php";}?>
<table style="width:500;margin:0 auto;margin-top:100px">
<tr><th>Trabalhando com a tabela usuários
<tr><td><a href="?url=consultar">consultar</a>
<tr><td><a href="?url=filtrar">filtrar</a>
<tr><td><a href="?url=adicionar">adicionar</a>
<tr><td><a href="?url=atualizar">atualizar</a>
<tr><td><a href="?url=excluir">excluir</a>
</body>
</html>
O seu autoload é excelente, mas eu não tenho coragem de usar a constante __DIR__.Discussão (2)
Carregando comentários...