DAL.php

<< Click to Display Table of Contents >>

Navigation:  Outros > CRUD com persistencia Orientada Objeto > persistencia >

DAL.php

Previous pageReturn to chapter overviewNext page

<?php
 
namespace persistencia;
 
use \PDO;
use \classes\Util;
 
class DAL {
   
    // usado internamente para conforme o $valor montar o param para PDO com NULL | INT | STR
    private static function getDataType($valor): int {
        // se o valor é nulo, um parametro especial
        if (is_null($valor)) {
            return PDO::PARAM_NULL;
        }
 
        // caso contrário ou é int ou str (não vi outros)
        if (is_int($valor)) {
            return PDO::PARAM_INT;
        } else {
            return PDO::PARAM_STR;
        }
    }
 
    public static function Desconectar() {
        Conexao::desconectar();
    }
 
    /**
     * Grava (insert ou update) um objeto na base de dados (deve possuir as anotações)
     * @param \persistencia\Modelo $objeto objeto a ser gravado - campos nulos serão validados
     * @return int retorna o id da base de dados no caso de insert.
     * @throws \Exception use o try para pegar possíveis erros
     */
    public static function Gravar($objeto): int {
 
        /** @var \persistencia\Modelo $objeto */
        $campo_chave_tem_valor = $objeto->isKeyContemValor();
 
        if ($campo_chave_tem_valor) {
            $sql = $objeto->getUpdateSQL();
        } else {
            $sql = $objeto->getInsertSQL();
        }
 
        // verifica se tem campo not null que não foi preenchido
        if (!$objeto->isTodasPropriedadesValidas($campo_chave_tem_valor)) {
            throw new \Exception($objeto->getMensagemValidacao());
        }
 
        // pega uma lista "campo => valor"
        $dados = $objeto->getCampoValores();
 
        // conecta na base e prepara o sql
        $conexao = Conexao::getConexao();
        $comando = $conexao->prepare($sql);
 
        // percorre todos os campos (com os valores)
        foreach ($dados as $campo => $valor) {
 
            $data_type = DAL::getDataType($valor);
            // echo ":" . $campo . " = " . $valor . " = " . $data_type . "<br/>";
            $comando->bindValue(":" . $campo$valor$data_type);
        }
 
        // executa o comando
        $comando->execute($dados);
        return $conexao->lastInsertId();
    }
 
    /**
     * Retorna um objeto da base localizando pelo id
     * @param \persistencia\Modelo $objeto coloque aqui uma instância do objeto (ex: new Pessoa())
     * @param int $id coloque o id chave para localizar no banco ex: 1
     * @return Modelo retorna um objeto que deve ser feito cast para usar usando @var
     */
    public static function GetObjectById($objeto$id) {
 
        /** @var Modelo $objeto */
        $sql = $objeto->getSelectSQL($id);
 
        $conexao = Conexao::getConexao();
 
        $comando = $conexao->prepare($sql);
        $comando->bindValue($objeto->getCampoChave(), $idDAL::getDataType($id));
        $comando->execute();
 
        // não use fetchAll() queremos só 1 registro
        $obj = $comando->fetch();
        if ($obj) {
            return Util::castObject($objget_class($objeto));
        } else {
            return null;
        }
    }
 
    // função privada usada pelo método GravarList
    private static function GravarUmObjeto($conexao$objeto): int {
 
        $retorno = 0;
        $campo_chave_tem_valor = $objeto->isKeyContemValor();
 
        if ($campo_chave_tem_valor) {
            $sql = $objeto->getUpdateSQL();
        } else {
            $sql = $objeto->getInsertSQL();
            $retorno = 1;
        }
 
        if (!$objeto->isTodasPropriedadesValidas($campo_chave_tem_valor)) {
            throw new \Exception($objeto->getMensagemValidacao());
        }
 
        // pega uma lista "campo => valor"
        $dados = $objeto->getCampoValores();
 
        // prepara o sql
        $comando = $conexao->prepare($sql);
 
        // percorre todos os campos (com os valores)
        foreach ($dados as $campo => $valor) {
 
            $data_type = DAL::getDataType($valor);
            // echo ":" . $campo . " = " . $valor . " = " . $data_type . "<br/>";
            $comando->bindValue(":" . $campo$valor$data_type);
        }
 
        // executa o comando
        $comando->execute($dados);
 
        // retorna 1 se foi insert
        return $retorno;
    }
 
    /**
     * Grava (insert ou update) uma lista de objetos dentro de uma transação
     * @param \persistencia\Modelo $lista lista de objetos a serem gravados na base, qualquer objeto que extende Modelo
     * @return int quantidade de registros INSERIDOS
     * @throws \PDOException caso dê um erro, use try
     */
    public static function GravarList($lista): int {
 
        /** @var Modelo[] $lista */
        $conexao = Conexao::getConexao();
        $qtd_inserts = 0;
 
        try {
            $conexao->beginTransaction();
 
            // vamos percorrer todos objetos e chamar uma função que vai montar ele e mandar pro banco
            /** @var Modelo $objeto */
            foreach ($lista as $objeto) {
                $qtd_inserts += DAL::GravarUmObjeto($conexao$objeto);
            }
 
            $conexao->commit();
        } catch (\PDOException $ex) {
            $conexao->rollBack();
            throw $ex;
        }
 
        return $qtd_inserts;
    }
 
    /** para usar de modo correto o cast\n
     * coloque isso quando usar essa funcao: @var Pessoa[] $lista acima de $lista = DAL::GetListObjects */
    public static function GetListObjects($objeto$where = null$order = null$limite = 0$offset = 0): array {
 
        $sql = $objeto->getSelectSQLSemWhere();
 
        if (isset($where) && strlen($where) > 0) {
            $sql .= " WHERE " . $where;
        }
 
        if (isset($order)) {
            $sql .= " ORDER BY " . $order;
        }
 
        if ($limite > 0) {
            $sql .= " LIMIT " . $limite;
        }
 
        if ($offset > 0) {
            $sql .= " OFFSET " . $offset;
        }
 
        $conexao = Conexao::getConexao();
        $qy = $conexao->query($sql);
 
        $saida = array();
        while ($obj = $qy->fetchObject(get_class($objeto))) {
            $saida[] = $obj;
        }
 
        return $saida;
    }
 
    /**
     * Excluir um registro da base de dados
     * @param \persistencia\Modelo $objeto instancia da classe para localizar use new Pessoa()
     * @param int $id codigo chave para exclusão
     */
    public static function Excluir($objeto$id) {
 
        /** @var Modelo $objeto */
        $sql = $objeto->getDeleteSQL($id);
 
        $conexao = Conexao::getConexao();
 
        $comando = $conexao->prepare($sql);
        $comando->bindValue($objeto->getCampoChave(), $idDAL::getDataType($id));
        $comando->execute();
    }
 
    /**
     * Retorna um array StdClass com base num sql
     * @param string $sql sql para fazer a consulta
     * @return array StdClass
     */
    public static function getListFromSQL($sql): array {
        $conexao = Conexao::getConexao();
        $qy = $conexao->query($sql);
        return $qy->fetchAll();
    }
 
}