Source for file model.classe.php

Documentation is available at model.classe.php

  1. <?php
  2.     /**
  3.      * ar.classe.php
  4.      * 
  5.      * Extende e configura ao ADODB Active Record
  6.      *
  7.      * @copyright 2008 Soomp
  8.      * @author Marcio Merlone <mmerlone@gmail.com>
  9.      * @version 1.0
  10.      * @since 03/04/2007
  11.      * @package Soomp
  12.      */
  13.  
  14.     /**
  15.      * O objeto que extender esta classe deve obrigatoriamente possuir as
  16.      * propriedades:
  17.      * * $pk com o nome do campo que armazena a chave primária do objeto
  18.      * <code>
  19.      * public $pk = 'PK_DA_TABELA';
  20.      * </code>
  21.      * 
  22.      * São propriedades opcionais do objeto:
  23.      * * $strOrdCampo que define o campo de ordenação das listagens por padrão
  24.      * caso não solicitado.
  25.      * Caso esta propriedade não seja definida será utilizado o $pk.
  26.      * <code>
  27.      * public $strOrdCampo = 'NO_NOME_NA_TABELA';
  28.      * </code>
  29.      * 
  30.      * Além destas, cada objeto pode ainda implementar suas próprias propriedades
  31.      * e métodos auxiliares.
  32.      */
  33.     abstract class model{
  34.  
  35.         /**
  36.          * @var string $_strTable nome da tabela com os dados
  37.          */
  38.         protected $_strTable;
  39.         /**
  40.          * @var string $_strFldPk nome do campo com o pk
  41.          */
  42.         protected $_strFldPk;
  43.         /**
  44.          * @var string $_strFldNo nome do campo com o nome
  45.          */
  46.         protected $_strFldNo;
  47.         /**
  48.          * @var boolean $_boolUserDb define se deve-se utilizar a conexão db de usuários
  49.          */
  50.         protected $_boolUserDb = false;
  51.  
  52.         /**
  53.          * Construtor
  54.          * Inicializa as propriedades do objeto com os campos do db
  55.          */
  56.         public function __construct(){
  57.             if($arrFlds = $this->getFields()){
  58.                 foreach(array_keys($arrFlds) as $strFld){
  59.                     $this->$strFld = null;
  60.                 }
  61.             }
  62.         }
  63.  
  64.         /**
  65.          * Lista registros com todos os dados necessários para paginação
  66.          * @param integer $intPag número da página solicitada
  67.          * @param integer $idListagem identificador da listagem para o caso de múltiplas
  68.          *  listagens do mesmo objeto na mesma tela.
  69.          * @return object $lista objeto de listagem com as propriedades de páginas,
  70.          *  registros, e array com os objetos da lista em si.
  71.          */
  72.         public function initPage($intPag = 1, $idListagem = 1, $useUserDb = false){
  73.             require_once(CFG_LOCAL_FRAMEWORK.'pager.classe.php');
  74.             $lista = pager::getInstance($this->_strTable, $idListagem, $this->_strFldPk);
  75.             $lista->_useUserDb    = $useUserDb;
  76.             $lista->intPag        = $intPag;
  77.             $lista->strOrdCampoDefault = $this->strOrdCampo;
  78.             $lista->strObjName = get_class($this);
  79.             return $lista;
  80.         }
  81.  
  82.         /**
  83.          * Processa a paginação de acordos com a solicitação
  84.          * @param object $lista o objeto de listagem
  85.          * @param array $arrDados array de dados a serem paginados ou critério de filtragem
  86.          * @return object $lista o objeto de listagem com os dados
  87.          */
  88.         public function Page(&$lista, $arrDados = false){
  89.             if($arrDados && is_array($arrDados)){
  90.                 $lista->getLista($arrDados);
  91.             }else{
  92.                 $qry = 'SELECT * FROM '.$this->_strTable;
  93.                 if($arrDados){
  94.                     $qry .= ' WHERE '.$arrDados;
  95.                 }
  96.                 $lista->getLista($qry);
  97.             }
  98.             return $lista;
  99.         }
  100.  
  101.         /**
  102.          * Retorna as colunas do DB para informar seus tamanhos
  103.          * @return array lista dos campos e respectivas informações
  104.          */
  105.         public function getFields(){
  106.             if($db = &$this->getDb()){
  107.                 return $db->MetaColumns($this->_strTable);
  108.             }
  109.             return false;
  110.         }
  111.  
  112.         /**
  113.          * Retorna o objeto de banco de dados a ser utilizado
  114.          * @return object $db objeto adodb com a conexão ou false se erro.
  115.          */
  116.         public function getDb(){
  117.  
  118.             require_once(CFG_LOCAL_FRAMEWORK.'stdio.classe.php');
  119.             global $ADODB_FETCH_MODE;
  120.             $ADODB_FETCH_MODE = ADODB_FETCH_ASSOC;
  121.             $stdio = stdio::getInstance();
  122.  
  123.             if($this->_boolUserDb && $stdio->_dbUser()){
  124.                 return $stdio->dbUser;
  125.  
  126.             }elseif(!$this->_boolUserDb && $stdio->_db()){
  127.                 return $stdio->db;
  128.             }
  129.             trigger_error('FATAL: model::getDb - erro conectando no banco de dados!', E_USER_WARNING);
  130.             return false;
  131.         }
  132.  
  133.         /**
  134.          * Carrega os dados do objeto
  135.          * @param mixed $who pk ou nome do objeto a ser carregado
  136.          */
  137.         public function Load($who){
  138.             if($db = &$this->getDb()){
  139.  
  140.                 if(is_numeric($who)){
  141.                     $fld = $this->_strFldPk;
  142.  
  143.                 }else{
  144.                     $fld = $this->_strFldNo;
  145.                 }
  146.  
  147.                 $qry = 'SELECT * FROM '.$this->_strTable.' WHERE '.$fld.'='.$db->qstr($who);
  148.                 $data = $db->GetRow($qry);
  149.  
  150.                 if($data){
  151.                     foreach($data as $key => $value){
  152.                         $this->$key = $value;
  153.                     }
  154.                     return true;
  155.                 }
  156.             }
  157.             return false;
  158.         }
  159.  
  160.         /**
  161.          * Salva um registro no banco de dados
  162.          * Caso o objeto possua um pk, atualiza seus dado, caso contrário
  163.          * insere um novo registro.
  164.          */
  165.         public function Save(){
  166.             if($db = &$this->getDb()){
  167.                 $arrFlds = array_keys($this->getFields());
  168.                 foreach($arrFlds as $fld){
  169.                     if(!is_null($this->$fld))
  170.                         $arrData[$fld] = $this->$fld;
  171.                 }
  172.                 $ok = $db->Replace($this->_strTable, $arrData, $this->_strFldPk, true);
  173.                 if($ok == 2){
  174.                     $this->{$this->_strFldPk} = $this->getId();
  175.                 }
  176.                 return $ok;
  177.             }
  178.         }
  179.  
  180.         /**
  181.          * Lista todos os registros de uma tabela que atendam a um critério
  182.          * @param mixed $where pode ser:
  183.          *  - string com a cláusula where completa ou valor vazio que implica em tudo
  184.          *  - numeric com um pk a procurar
  185.          *  - array com valores de pk a procurar
  186.          * @return array $arrData array de objetos
  187.          */
  188.         public function Find($where){
  189.             if($db = &$this->getDb()){
  190.                 
  191.                 if(empty($where)){
  192.                     $where = '1=1';
  193.                 }elseif(is_array($where)){
  194.                     $where = $this->_strFldPk.' IN ("'.join('","', $where).'")';
  195.                 }elseif(is_numeric($where)){
  196.                     $where = $this->_strFldPk.'='.$db->qstr($where);
  197.                 }
  198.                 $qry = 'SELECT * FROM '.$this->_strTable.' WHERE '.$where;
  199.                 $arrRet = $db->GetAll($qry);
  200.  
  201.                 $arrData = array();
  202.                 if($arrRet){
  203.                     foreach($arrRet as $arrObj){
  204.                         $objClass = get_class($this);
  205.                         $objRet = new $objClass();
  206.                         if($objRet->Set($arrObj)){
  207.                             $arrData[] = $objRet;
  208.                         }
  209.                     }
  210.                 }
  211.                 return $arrData;
  212.             }
  213.             return false;
  214.         }
  215.  
  216.         /**
  217.          * Remove do banco de dados um ou mais registros
  218.          * @param array $arrPks pks a serem removidos
  219.          */
  220.         public function Delete($arrPks = array()){
  221.             if(empty($arrPks)){
  222.                 if(!$this->{$this->_strFldPk}){
  223.                     return false;
  224.                 }else{
  225.                     return $this->Delete(array($this->{$this->_strFldPk}));
  226.                 }
  227.  
  228.             }else{
  229.                 if($db = &$this->getDb()){
  230.                     $ok = true;
  231.                     foreach($arrPks as $pk){
  232.                         $sql = 'DELETE FROM '.$this->_strTable.' WHERE '.$this->_strFldPk.'='.$db->qstr($pk);
  233.                         $ok = $ok && $db->Execute($sql);
  234.                     }
  235.                     return $ok ? true : false;
  236.                 }
  237.                 return false;
  238.             }
  239.         }
  240.  
  241.         /**
  242.          * Define as propriedades de um objeto baseado em um array associativo
  243.          * @param array $row array com os dados
  244.          */
  245.         public function Set($row){
  246.             if($db = &$this->getDb()){
  247.                 if (!$row) return false;
  248.                 foreach($row as $key => $value) {
  249.                     $this->$key = $value;
  250.                 }
  251.                 return true;
  252.             }
  253.             return false;
  254.         }
  255.  
  256.         /**
  257.          * Retorna o pk de um objeto recém inserido.
  258.          * @param string $strNo valor em $this->_strFldNo aser buscado
  259.          * @return integer $pk pk do objeto
  260.          */
  261.         private function getId($strNo = null){
  262.             $pk = false;
  263.             if($db = &$this->getDb()){
  264.                 if(!$strNo){
  265.                     if($this->{$this->_strFldNo}){
  266.                         $strNo = $this->_strFldNo;
  267.                     }else{
  268.                         return false;
  269.                     }
  270.                 }
  271.                 if(!$pk = $db->Insert_ID()){
  272.                     $qry = 'SELECT '.$this->_strFldPk.' FROM '.$this->_strTable.' WHERE '.$this->_strFldNo.'='.$db->qstr($this->{$this->_strFldPk});
  273.                     list($pk) = $db->GetRow($qry);
  274.                 }
  275.             }
  276.             return $pk;
  277.         }
  278.  
  279.     }
  280.  
  281. ?>

Documentation generated on Sun, 09 Mar 2008 23:52:19 -0300 by phpDocumentor 1.4.0

SourceForge.net Logo Support This Project