Source for file OnpubAuthors.php

Documentation is available at OnpubAuthors.php

  1. <?php
  2.  
  3. /**
  4.  * Manage authors in an Onpub database.
  5.  *
  6.  * @author {@link mailto:corey@onpub.com Corey H.M. Taylor}
  7.  * @copyright Onpub (TM). Copyright 2012, Onpub.com.
  8.  *  {@link http://onpub.com/}
  9.  * @license http://www.gnu.org/copyleft/gpl.html GNU General Public License
  10.  *  Version 2
  11.  * @package OnpubAPI
  12.  */
  13. {
  14.   private $pdo;
  15.   /**
  16.    * @var bool 
  17.    */
  18.   public $enableTransactions;
  19.  
  20.   /**
  21.    * Connect to an Onpub database.
  22.    *
  23.    * All the methods in this class which query the database use the database
  24.    * connection provided by the PDO object required by this constructor.
  25.    * Currently, Onpub only supports MySQL as a database for storing content.
  26.    * Therefore, when constructing the PDO object, only the
  27.    * {@link PHP_MANUAL#ref.pdo-mysql PDO_MYSQL} driver is supported
  28.    * as a PDO {@link PHP_MANUAL#ref.pdo-mysql.connection data source}.
  29.    *
  30.    * All the methods in this class require the
  31.    * {@link http://onpub.com/pdfs/onpub_schema.pdf Onpub schema}
  32.    * to be installed in the PDO-connected database. The {@link OnpubDatabase}
  33.    * class contains methods to manage the Onpub schema. The Onpub
  34.    * schema can also be installed by clicking the "Install the schema" link
  35.    * once logged in to the Onpub web interface. The schema generally only has
  36.    * to be installed once per database.
  37.    *
  38.    * @param PDO $pdo {@link PHP_MANUAL#function.pdo-construct PHP Data Object}.
  39.    * @param bool $enableTransactions 
  40.    */
  41.   function __construct(PDO $pdo$enableTransactions TRUE)
  42.   {
  43.     $this->pdo $pdo;
  44.     $this->enableTransactions = $enableTransactions;
  45.     $this->pdo->setAttribute(PDO::ATTR_EMULATE_PREPARESTRUE);
  46.   }
  47.  
  48.   /**
  49.    * @return int 
  50.    */
  51.   public function count()
  52.   {
  53.     $query $this->countQuery();
  54.     $result $this->pdo->query($query);
  55.     OnpubDatabase::verifyQuery($this->pdo$resultFALSE);
  56.  
  57.     if (!($row $result->fetch(PDO::FETCH_ASSOC))) {
  58.       return 0;
  59.     }
  60.  
  61.     $result->closeCursor();
  62.     return $row["count"];
  63.   }
  64.  
  65.   private function countQuery()
  66.   {
  67.     return "SELECT COUNT(ID) AS count FROM OnpubAuthors";
  68.   }
  69.  
  70.   /**
  71.    * @param int $ID ID of the author to get.
  72.    * @return OnpubAuthor An {@link OnpubAuthor} object. NULL if the author does not exist in the database.
  73.    */
  74.   public function get($ID)
  75.   {
  76.     $query $this->getQuery($ID);
  77.     $result $this->pdo->query($query);
  78.     OnpubDatabase::verifyQuery($this->pdo$resultFALSE);
  79.  
  80.     if (!($row $result->fetch(PDO::FETCH_ASSOC))) {
  81.       return NULL;
  82.     }
  83.  
  84.     $author new OnpubAuthor();
  85.  
  86.     $author->ID $row["ID"];
  87.     $author->imageID $row["imageID"];
  88.     $author->givenNames $row["givenNames"];
  89.     $author->familyName $row["familyName"];
  90.     $author->displayAs $row["displayAs"];
  91.     $author->url $row["url"];
  92.     $author->setCreated(new DateTime($row["created"]));
  93.     $author->setModified(new DateTime($row["modified"]));
  94.  
  95.     $result->closeCursor();
  96.     return $author;
  97.   }
  98.  
  99.   private function getQuery($ID)
  100.   {
  101.     return "SELECT * FROM OnpubAuthors WHERE ID = $ID";
  102.   }
  103.  
  104.   /**
  105.    * @param OnpubAuthor $author Author whose ID you want to get.
  106.    * @return int The ID of the author. NULL if the author does not exist in the database.
  107.    */
  108.   public function getID(OnpubAuthor $author)
  109.   {
  110.     $stmt $this->pdo->prepare("SELECT ID FROM OnpubAuthors WHERE displayAs = :displayAs");
  111.     OnpubDatabase::verifyPrepare($this->pdo$stmtFALSE);
  112.  
  113.     $displayAs OnpubDatabase::utf8Decode(trim($author->displayAs));
  114.  
  115.     $stmt->bindParam(':displayAs'$displayAs);
  116.     $result $stmt->execute();
  117.     OnpubDatabase::verifyExecute($this->pdo$resultFALSE$stmt->errorInfo());
  118.  
  119.     if (($row $stmt->fetch(PDO::FETCH_ASSOC))) {
  120.       return $row["ID"];
  121.     }
  122.  
  123.     return NULL;
  124.   }
  125.  
  126.   /**
  127.    * @param OnpubQueryOptions $queryOptions Database query options.
  128.    * @return array An array of {@link OnpubAuthor} objects.
  129.    */
  130.   public function select(OnpubQueryOptions $queryOptions NULL)
  131.   {
  132.     if ($queryOptions === NULL)
  133.       $queryOptions new OnpubQueryOptions();
  134.  
  135.     $query $this->selectQuery($queryOptions);
  136.     $result $this->pdo->query($query);
  137.     OnpubDatabase::verifyQuery($this->pdo$resultFALSE);
  138.     $rows $result->fetchAll(PDO::FETCH_ASSOC);
  139.  
  140.     $authors array();
  141.  
  142.     if ($rows{
  143.       foreach ($rows as $row{
  144.         $author new OnpubAuthor();
  145.  
  146.         $author->ID $row["ID"];
  147.         $author->imageID $row["imageID"];
  148.         $author->givenNames $row["givenNames"];
  149.         $author->familyName $row["familyName"];
  150.         $author->displayAs $row["displayAs"];
  151.         $author->url $row["url"];
  152.         $author->setCreated(new DateTime($row["created"]));
  153.         $author->setModified(new DateTime($row["modified"]));
  154.  
  155.         $authors[$author;
  156.       }
  157.     }
  158.  
  159.     $result->closeCursor();
  160.     return $authors;
  161.   }
  162.  
  163.   private function selectQuery(OnpubQueryOptions $queryOptions NULL)
  164.   {
  165.     if ($queryOptions === NULL)
  166.       $queryOptions new OnpubQueryOptions();
  167.  
  168.     $where "";
  169.     $orderBy "";
  170.     $limit "";
  171.  
  172.     if ($queryOptions->dateLimit{
  173.       $where "WHERE created <= "
  174.         . $this->pdo->quote($queryOptions->dateLimit->format('Y-m-d H:i:s'));
  175.     }
  176.  
  177.     if ($queryOptions->orderBy{
  178.       $orderBy "ORDER BY " $queryOptions->orderBy;
  179.  
  180.       if ($queryOptions->order{
  181.         $orderBy .= " " $queryOptions->order;
  182.       }
  183.     }
  184.  
  185.     if ($queryOptions->getPage(&& $queryOptions->rowLimit && $queryOptions->rowLimit 0{
  186.       $limit "LIMIT "
  187.         . (($queryOptions->getPage(1$queryOptions->rowLimit","
  188.         . $queryOptions->rowLimit;
  189.     }
  190.     elseif ($queryOptions->rowLimit && $queryOptions->rowLimit 0{
  191.       $limit "LIMIT 0," $queryOptions->rowLimit;
  192.     }
  193.  
  194.     return "SELECT ID, imageID, givenNames, familyName, displayAs, url, created, modified FROM OnpubAuthors $where $orderBy $limit";
  195.   }
  196.  
  197.   /**
  198.    * @param mixed $authors A single {@link OnpubAuthor} object or an array of {@link OnpubAuthor} objects (to insert multiple authors at a time).
  199.    * @return mixed The ID(s) of the new author(s). An int will be returned if a single author was inserted. An array of ints will be returned if multiple authors were inserted.
  200.    * @throws PDOException if there's a database error.
  201.    */
  202.   public function insert($authors)
  203.   {
  204.     $oimages new OnpubImages($this->pdoFALSE);
  205.     $IDs array();
  206.     $isArray TRUE;
  207.  
  208.     if (!is_array($authors)) {
  209.       $authors array ($authors);
  210.       $isArray FALSE;
  211.     }
  212.  
  213.     if ($this->enableTransactions{
  214.       $status $this->pdo->beginTransaction();
  215.       OnpubDatabase::verifyTransaction($this->pdo$status);
  216.     }
  217.  
  218.     $stmt $this->pdo->prepare("INSERT INTO OnpubAuthors (ID, imageID, givenNames, familyName, displayAs, url, created, modified) VALUES (:ID, :imageID, :givenNames, :familyName, :displayAs, :url, :created, :modified)");
  219.     OnpubDatabase::verifyPrepare($this->pdo$stmt$this->enableTransactions);
  220.  
  221.     foreach ($authors as $author{
  222.       if ($author->image{
  223.         try {
  224.           $imageID $oimages->insert($author->image);
  225.           $author->imageID $imageID;
  226.         }
  227.         catch (PDOException $e{
  228.           if ($this->enableTransactions)
  229.             $this->pdo->rollBack();
  230.  
  231.           throw $e;
  232.         }
  233.       }
  234.  
  235.       try {
  236.         $ID $this->getID($author);
  237.       }
  238.       catch (PDOException $e{
  239.         if ($this->enableTransactions)
  240.           $this->pdo->rollBack();
  241.  
  242.         throw $e;
  243.       }
  244.  
  245.       if ($ID{
  246.         $IDs[$ID;
  247.         $author->ID $ID;
  248.       }
  249.       else {
  250.         $ID $author->ID;
  251.         $imageID $author->imageID;
  252.         $givenNames OnpubDatabase::utf8Decode(trim($author->givenNames));
  253.         $familyName OnpubDatabase::utf8Decode(trim($author->familyName));
  254.         $displayAs OnpubDatabase::utf8Decode(trim($author->displayAs));
  255.         $url OnpubDatabase::utf8Decode(trim($author->url));
  256.         $created $author->getCreated()->format('Y-m-d H:i:s');
  257.         $modified $author->getModified()->format('Y-m-d H:i:s');
  258.  
  259.         $stmt->bindParam(':ID'$ID);
  260.         $stmt->bindParam(':imageID'$imageID);
  261.         $stmt->bindParam(':givenNames'$givenNames);
  262.         $stmt->bindParam(':familyName'$familyName);
  263.         $stmt->bindParam(':displayAs'$displayAs);
  264.         $stmt->bindParam(':url'$url);
  265.         $stmt->bindParam(':created'$created);
  266.         $stmt->bindParam(':modified'$modified);
  267.         $result $stmt->execute();
  268.         OnpubDatabase::verifyExecute($this->pdo$result$this->enableTransactions$stmt->errorInfo());
  269.  
  270.         $IDs[$this->pdo->lastInsertId();
  271.         $author->ID $this->pdo->lastInsertId();
  272.       }
  273.     }
  274.  
  275.     if ($this->enableTransactions{
  276.       $status $this->pdo->commit();
  277.       OnpubDatabase::verifyTransaction($this->pdo$status);
  278.     }
  279.  
  280.     if ($isArray{
  281.       return $IDs;
  282.     }
  283.     else {
  284.       return end($IDs);
  285.     }
  286.   }
  287.  
  288.   /**
  289.    * @param OnpubAuthor $author The author to be updated.
  290.    * @return int 1 if the author was updated. 0 if the author does not exist in the database.
  291.    */
  292.   public function update(OnpubAuthor $author)
  293.   {
  294.     $now new DateTime();
  295.  
  296.     if ($this->enableTransactions{
  297.       $status $this->pdo->beginTransaction();
  298.       OnpubDatabase::verifyTransaction($this->pdo$status);
  299.     }
  300.  
  301.     $stmt $this->pdo->prepare("UPDATE OnpubAuthors SET imageID = :imageID, givenNames = :givenNames, familyName = :familyName, displayAs = :displayAs, url = :url, modified = :modified WHERE ID = :ID");
  302.     OnpubDatabase::verifyPrepare($this->pdo$stmt$this->enableTransactions);
  303.  
  304.     $ID $author->ID;
  305.     $imageID $author->imageID;
  306.     $givenNames OnpubDatabase::utf8Decode(trim($author->givenNames));
  307.     $familyName OnpubDatabase::utf8Decode(trim($author->familyName));
  308.     $displayAs OnpubDatabase::utf8Decode(trim($author->displayAs));
  309.     $url OnpubDatabase::utf8Decode(trim($author->url));
  310.     $modified $now->format('Y-m-d H:i:s');
  311.  
  312.     $stmt->bindParam(':ID'$ID);
  313.     $stmt->bindParam(':imageID'$imageID);
  314.     $stmt->bindParam(':givenNames'$givenNames);
  315.     $stmt->bindParam(':familyName'$familyName);
  316.     $stmt->bindParam(':displayAs'$displayAs);
  317.     $stmt->bindParam(':url'$url);
  318.     $stmt->bindParam(':modified'$modified);
  319.  
  320.     $result $stmt->execute();
  321.     OnpubDatabase::verifyExecute($this->pdo$result$this->enableTransactions$stmt->errorInfo());
  322.  
  323.     if ($this->enableTransactions{
  324.       $status $this->pdo->commit();
  325.       OnpubDatabase::verifyTransaction($this->pdo$status);
  326.     }
  327.  
  328.     return $stmt->rowCount();
  329.   }
  330. }
  331. ?>

Documentation generated on Fri, 08 Feb 2013 04:02:19 -0500 by phpDocumentor 1.4.4