/estadisticas/estadisticas/application/models/catalogs/PersonCatalog.php

<?php
/**
 * Bender Modeler
 *
 * Our Simple Models
 *
 * @category   lib
 * @package    lib_models
 * @copyright  Copyright (c) 2008-2010 Bender Modeler (http://www.ctrl-zetta.com/#code)
 * @author     <zetta> <chentepixtol>, $LastChangedBy$
 * @version    1.0.0 SVN: $Id$
 */

/**
 * Dependences
 */
require_once "lib/db/Catalog.php";
require_once "application/models/beans/Person.php";
require_once "application/models/exceptions/PersonException.php";
require_once "application/models/collections/PersonCollection.php";
require_once "application/models/factories/PersonFactory.php";

/**
 * Singleton PersonCatalog Class
 *
 * @category   lib
 * @package    lib_models
 * @subpackage lib_models_catalogs
 * @copyright  Copyright (c) 2008-2010 Bender Modeler (http://www.ctrl-zetta.com/#code)
 * @copyright  This File as been proudly generated by Bender (http://code.google.com/p/bender-modeler/). <chentepixtol> <zetta>
 * @author     zetta & chentepixtol
 * @version    1.0.0 SVN: $Revision$
 */
class PersonCatalog extends Catalog
{

    /**
     * Singleton Instance
     * @var PersonCatalog
     */
    static protected $instance = null;


    /**
     * Método para obtener la instancia del catálogo
     * @return PersonCatalog
     */
    public static function getInstance()
    {
        if (!isset(self::$instance))
        {
          self::$instance = new self();
        }
        return self::$instance;
    }
    
    /**
     * Constructor de la clase PersonCatalog
     * @return PersonCatalog
     */
    protected function PersonCatalog()
    {
        parent::Catalog();
    }

    /**
     * Metodo para agregar un Person a la base de datos
     * @param Person $person Objeto Person
     */
    public function create($person)
    {
        if(!($person instanceof Person))
            throw new PersonException("passed parameter isn't a Person instance");
        try
        {
            $data = array(
                'name' => $person->getName(),
                'middle_name' => $person->getMiddleName(),
                'last_name' => $person->getLastName(),
                'date_birthdate' => $person->getDateBirthdate(),
                'genre' => $person->getGenre(),
                'marital_status' => $person->getMaritalStatus(),
                'curp' => $person->getCurp(),
            );
            $data = array_filter($data, 'Catalog::notNull');
            $this->db->insert(Person::TABLENAME, $data);
            $person->setIdPerson($this->db->lastInsertId());
        }
        catch(Exception $e)
        {
            throw new PersonException("The Person can't be saved \n" . $e->getMessage());
        }
    }

    /**
     * Metodo para Obtener los datos de un objeto por su llave primaria
     * @param int $idPerson
     * @return Person|null
     */
    public function getById($idPerson)
    {
        try
        {
            $criteria = new Criteria();
            $criteria->add(Person::ID_PERSON, $idPerson, Criteria::EQUAL);
            $newPerson = $this->getByCriteria($criteria)->getOne();
        }
        catch(Exception $e)
        {
            throw new PersonException("Can't obtain the Person \n" . $e->getMessage());
        }
        return $newPerson;
    }
    
    /**
     * Metodo para Obtener una colección de objetos por varios ids
     * @param array $ids
     * @return PersonCollection
     */
    public function getByIds(array $ids)
    {
        if(null == $ids) return new PersonCollection();
        try
        {
            $criteria = new Criteria();
            $criteria->add(Person::ID_PERSON, $ids, Criteria::IN);
            $personCollection = $this->getByCriteria($criteria);
        }
        catch(Exception $e)
        {
            throw new PersonException("PersonCollection can't be populated\n" . $e->getMessage());
        }
        return $personCollection;
    }

    /**
     * Metodo para Obtener todos los ids en un arreglo
     * @return array
     */
    public function retrieveAllIds()
    {
        try
        {
            $result = $this->db->fetchCol('SELECT id_person FROM '.Person::TABLENAME);
        }
        catch(Exception $e)
        {
            throw new PersonException("Can't obtain the ids\n" . $e->getMessage());
        }
        return $result;
    }

    /**
     * Metodo para actualizar un Person
     * @param Person $person 
     */
    public function update($person)
    {
        if(!($person instanceof Person))
            throw new PersonException("passed parameter isn't a Person instance");
        try
        {
            $where[] = "id_person = '{$person->getIdPerson()}'";
            $data = array(
                'name' => $person->getName(),
                'middle_name' => $person->getMiddleName(),
                'last_name' => $person->getLastName(),
                'date_birthdate' => $person->getDateBirthdate(),
                'genre' => $person->getGenre(),
                'marital_status' => $person->getMaritalStatus(),
                'curp' => $person->getCurp(),
            );
            $data = array_filter($data, 'Catalog::notNull');
            $this->db->update(Person::TABLENAME, $data, $where);
        }
        catch(Exception $e)
        {
            throw new PersonException("The Person can't be updated \n" . $e->getMessage());
        }
    }
    
    /**
     * Metodo para guardar un person
     * @param Person $person
     */	
    public function save($person)
    {
        if(!($person instanceof Person))
            throw new PersonException("passed parameter isn't a Person instance");
        if(null != $person->getIdPerson())
            $this->update($person);
        else
            $this->create($person);
    }

    /**
     * Metodo para eliminar un person
     * @param Person $person
     */
    public function delete($person)
    {
        if(!($person instanceof Person))
            throw new PersonException("passed parameter isn't a Person instance");
        $this->deleteById($person->getIdPerson());
    }

    /**
     * Metodo para eliminar un Person a partir de su Id
     * @param int $idPerson
     */
    public function deleteById($idPerson)
    {
        try
        {
            $where = array($this->db->quoteInto('id_person = ?', $idPerson));
            $this->db->delete(Person::TABLENAME, $where);
        }
        catch(Exception $e)
        {
            throw new PersonException("The Person can't be deleted\n" . $e->getMessage());
        }
    }
    
    /**
     * Metodo para eliminar varios Person a partir de su Id
     * @param array $ids
     */
    public function deleteByIds(array $ids)
    {
        try
        {
            $criteria = new Criteria();
            $criteria->add(Person::ID_PERSON, $ids, Criteria::IN);
            $this->db->delete(Person::TABLENAME, array($criteria->createSql()));
        }
        catch(Exception $e)
        {
            throw new PersonException("Can't delete that\n" . $e->getMessage());
        }
    }

    /**
     * Metodo para obtener todos los id de Person por criterio
     * @param Criteria $criteria
     * @return array Array con todos los id de Person que encajen en la busqueda
     */
    public function getIdsByCriteria(Criteria $criteria = null)
    {
        $criteria = (null === $criteria) ? new Criteria() : $criteria;
        try
        {
            $sql = "SELECT id_person
                    FROM ".Person::TABLENAME."
                    WHERE  " . $criteria->createSql();
            $ids = $this->db->fetchCol($sql);
        } catch(Exception $e)
        {
            throw new PersonException("Can't obtain Person's id\n" . $e->getMessage());
        }
        return $ids;
    }

    /**
     * Metodo para obtener un campo en particular de un Person dado un criterio
     * @param string $field
     * @param Criteria $criteria
     * @return array Array con el campo de los objetos Person que encajen en la busqueda
     */
    public function getCustomFieldByCriteria($field, Criteria $criteria = null)
    { 
        $criteria = (null === $criteria) ? new Criteria() : $criteria;
        try
        {
            $sql = "SELECT {$field}
                    FROM ".Person::TABLENAME."
                    WHERE  " . $criteria->createSql();
            $result = $this->db->fetchCol($sql);
        } catch(Zend_Db_Exception $e)
        {
            throw new PersonException("No se pudieron obtener los ids de objetos {$Bean}\n" . $e->getMessage());
        }
        return $result;
    }

    /**
     * Metodo que regresa una coleccion de objetos Person 
     * dependiendo del criterio establecido
     * @param Criteria $criteria
     * @return PersonCollection $personCollection
     */
    public function getByCriteria(Criteria $criteria = null)
    {
        $criteria = (null === $criteria) ? new Criteria() : $criteria;
        $this->db->setFetchMode(Zend_Db::FETCH_ASSOC);
        try 
        {
            $sql = "SELECT * FROM ".Person::TABLENAME."
                    WHERE " . $criteria->createSql();
            $personCollection = new PersonCollection();
            foreach ($this->db->fetchAll($sql) as $result){
                $personCollection->append($this->getPersonInstance($result));
            }
        }
        catch(Zend_Db_Exception $e)
        {
            throw new PersonException("Cant obtain PersonCollection\n" . $e->getMessage());
        }
        return $personCollection;
    }
    
    /**
     * Metodo que cuenta Person 
     * dependiendo del criterio establecido
     * @param Criteria $criteria
     * @param string $field
     * @return int $count
     */
    public function countByCriteria(Criteria $criteria = null, $field = 'id_person')
    {
        $criteria = (null === $criteria) ? new Criteria() : $criteria;
        try 
        {
            $sql = "SELECT COUNT( $field ) FROM ".Person::TABLENAME."
                    WHERE " . $criteria->createSql();   
            $count = $this->db->fetchOne($sql);
        }
        catch(Zend_Db_Exception $e)
        {
            throw new PersonException("Cant obtain the count \n" . $e->getMessage());
        }
        return $count;
    }
    
    /**
     * Método que construye un objeto Person y lo rellena con la información del rowset
     * @param array $result El arreglo que devolvió el objeto Zend_Db despues del fetch
     * @return Person 
     */
    private function getPersonInstance($result)
    {
        return PersonFactory::createFromArray($result);
    }

}