Source for file OnpubAAMaps.php

Documentation is available at OnpubAAMaps.php

  1. <?php
  2.  
  3. /**
  4.  * Manage article-author maps in an Onpub database.
  5.  *
  6.  * This class contains the methods to manage the data contained in an
  7.  * {@link http://onpub.com/pdfs/onpub_schema.pdf OnpubAAMaps table}. An
  8.  * OnpubAAMaps table maps article IDs to author IDs. This allows Onpub to do
  9.  * the following without any duplication of article/author data:
  10.  * - Use the same author for multiple articles.
  11.  * - A single article can have multiple authors.
  12.  * - Specify the order of an article's authors.
  13.  *
  14.  * @author {@link mailto:corey@onpub.com Corey H.M. Taylor}
  15.  * @copyright Onpub (TM). Copyright 2012, Onpub.com.
  16.  *  {@link http://onpub.com/}
  17.  * @license http://www.gnu.org/copyleft/gpl.html GNU General Public License
  18.  *  Version 2
  19.  * @package OnpubAPI
  20.  */
  21. class OnpubAAMaps
  22. {
  23.   private $pdo;
  24.   /**
  25.    * @var bool 
  26.    */
  27.   public $enableTransactions;
  28.  
  29.   /**
  30.    * Connect to an Onpub database.
  31.    *
  32.    * All the methods in this class which query the database use the database
  33.    * connection provided by the PDO object required by this constructor.
  34.    * Currently, Onpub only supports MySQL as a database for storing content.
  35.    * Therefore, when constructing the PDO object, only the
  36.    * {@link PHP_MANUAL#ref.pdo-mysql PDO_MYSQL} driver is supported
  37.    * as a PDO {@link PHP_MANUAL#ref.pdo-mysql.connection data source}.
  38.    *
  39.    * All the methods in this class require the
  40.    * {@link http://onpub.com/pdfs/onpub_schema.pdf Onpub schema}
  41.    * to be installed in the PDO-connected database. The {@link OnpubDatabase}
  42.    * class contains methods to manage the Onpub schema. The Onpub
  43.    * schema can also be installed by clicking the "Install the schema" link
  44.    * once logged in to the Onpub web interface. The schema generally only has
  45.    * to be installed once per database.
  46.    *
  47.    * @param PDO $pdo A {@link PHP_MANUAL#function.pdo-construct PHP Data Object}.
  48.    * @param bool $enableTransactions 
  49.    */
  50.   function __construct(PDO $pdo, $enableTransactions = TRUE)
  51.   {
  52.     $this->pdo = $pdo;
  53.     $this->enableTransactions = $enableTransactions;
  54.     $this->pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, TRUE);
  55.   }
  56.  
  57.   /**
  58.    * @param int $articleID Delete the map(s) with articleID.
  59.    * @param int $authorID Delete the map(s) with authorID.
  60.    * @return int The number of maps deleted, 0 if no maps were deleted.
  61.    */
  62.   public function delete($articleID, $authorID)
  63.   {
  64.     if ($articleID && $authorID) {
  65.       $stmt = $this->pdo->prepare("DELETE FROM OnpubAAMaps WHERE articleID = :articleID AND authorID = :authorID");
  66.       OnpubDatabase::verifyPrepare($this->pdo, $stmt, FALSE);
  67.       $stmt->bindParam(':articleID', $articleID);
  68.       $stmt->bindParam(':authorID', $authorID);
  69.     }
  70.  
  71.     if ($articleID && !$authorID) {
  72.       $stmt = $this->pdo->prepare("DELETE FROM OnpubAAMaps WHERE articleID = :articleID");
  73.       OnpubDatabase::verifyPrepare($this->pdo, $stmt, FALSE);
  74.       $stmt->bindParam(':articleID', $articleID);
  75.     }
  76.  
  77.     if (!$articleID && $authorID) {
  78.       $stmt = $this->pdo->prepare("DELETE FROM OnpubAAMaps WHERE authorID = :authorID");
  79.       OnpubDatabase::verifyPrepare($this->pdo, $stmt, FALSE);
  80.       $stmt->bindParam(':authorID', $authorID);
  81.     }
  82.  
  83.     $result = $stmt->execute();
  84.     OnpubDatabase::verifyExecute($this->pdo, $result, FALSE, $stmt->errorInfo());
  85.  
  86.     return $stmt->rowCount();
  87.   }
  88.  
  89.   /**
  90.    * @param OnpubQueryOptions $queryOptions Database query options.
  91.    * @return array An array of {@link OnpubAAMap} objects.
  92.    */
  93.   public function select(OnpubQueryOptions $queryOptions = NULL)
  94.   {
  95.     if ($queryOptions === NULL)
  96.       $queryOptions = new OnpubQueryOptions();
  97.  
  98.     $query = $this->selectQuery($queryOptions);
  99.     $result = $this->pdo->query($query);
  100.     OnpubDatabase::verifyQuery($this->pdo, $result, FALSE);
  101.     $rows = $result->fetchAll(PDO::FETCH_ASSOC);
  102.  
  103.     $aamaps = array();
  104.  
  105.     if ($rows) {
  106.       foreach ($rows as $row) {
  107.         $aamap = new OnpubAAMap();
  108.  
  109.         $aamap->ID = $row["ID"];
  110.         $aamap->articleID = $row["articleID"];
  111.         $aamap->authorID = $row["authorID"];
  112.         $aamap->setCreated(new DateTime($row["created"]));
  113.         $aamap->setModified(new DateTime($row["modified"]));
  114.  
  115.         $aamaps[] = $aamap;
  116.       }
  117.     }
  118.  
  119.     $result->closeCursor();
  120.     return $aamaps;
  121.   }
  122.  
  123.   private function selectQuery(OnpubQueryOptions $queryOptions = NULL)
  124.   {
  125.     if ($queryOptions === NULL)
  126.       $queryOptions = new OnpubQueryOptions();
  127.  
  128.     $where = "";
  129.     $orderBy = "";
  130.     $limit = "";
  131.  
  132.     if ($queryOptions->dateLimit) {
  133.       $where = "WHERE created <= "
  134.         . $this->pdo->quote($queryOptions->dateLimit->format('Y-m-d H:i:s'));
  135.     }
  136.  
  137.     if ($queryOptions->orderBy) {
  138.       $orderBy = "ORDER BY " . $queryOptions->orderBy;
  139.  
  140.       if ($queryOptions->order) {
  141.         $orderBy .= " " . $queryOptions->order;
  142.       }
  143.     }
  144.  
  145.     if ($queryOptions->getPage() && $queryOptions->rowLimit && $queryOptions->rowLimit > 0) {
  146.       $limit = "LIMIT "
  147.         . (($queryOptions->getPage() - 1) * $queryOptions->rowLimit) . ","
  148.         . $queryOptions->rowLimit;
  149.     }
  150.     elseif ($queryOptions->rowLimit && $queryOptions->rowLimit > 0) {
  151.       $limit = "LIMIT 0," . $queryOptions->rowLimit;
  152.     }
  153.  
  154.     return "SELECT ID, articleID, authorID, created, modified FROM OnpubAAMaps $where $orderBy $limit";
  155.   }
  156.  
  157.   /**
  158.    * @param OnpubAAMap $aamap Map whose ID you want to get.
  159.    * @return int The ID of the map. NULL if the map does not exist in the database.
  160.    */
  161.   public function getID(OnpubAAMap $aamap)
  162.   {
  163.     $stmt = $this->pdo->prepare("SELECT ID FROM OnpubAAMaps WHERE articleID = :articleID AND authorID = :authorID");
  164.     OnpubDatabase::verifyPrepare($this->pdo, $stmt, FALSE);
  165.  
  166.     $articleID = $aamap->articleID;
  167.     $authorID = $aamap->authorID;
  168.  
  169.     $stmt->bindParam(':articleID', $articleID);
  170.     $stmt->bindParam(':authorID', $authorID);
  171.     $result = $stmt->execute();
  172.     OnpubDatabase::verifyExecute($this->pdo, $result, FALSE, $stmt->errorInfo());
  173.  
  174.     if (($row = $stmt->fetch(PDO::FETCH_ASSOC))) {
  175.       return $row["ID"];
  176.     }
  177.  
  178.     return NULL;
  179.   }
  180.  
  181.   /**
  182.    * @param mixed $aamaps A single {@link OnpubAAMap} object or an array of {@link OnpubAAMap} objects (to insert multiple maps at a time).
  183.    * @return mixed The ID(s) of the new map(s). An int will be returned if a single map was inserted. An array of ints will be returned if multiple maps were inserted.
  184.    * @throws PDOException if there's a database error.
  185.    */
  186.   public function insert($aamaps)
  187.   {
  188.     $aamapIDs = array();
  189.     $isArray = TRUE;
  190.  
  191.     if (!is_array($aamaps)) {
  192.       $aamaps = array ($aamaps);
  193.       $isArray = FALSE;
  194.     }
  195.  
  196.     if ($this->enableTransactions) {
  197.       $status = $this->pdo->beginTransaction();
  198.       OnpubDatabase::verifyTransaction($this->pdo, $status);
  199.     }
  200.  
  201.     $stmt = $this->pdo->prepare("INSERT INTO OnpubAAMaps (ID, articleID, authorID, created, modified) VALUES (:ID, :articleID, :authorID, :created, :modified)");
  202.     OnpubDatabase::verifyPrepare($this->pdo, $stmt, $this->enableTransactions);
  203.  
  204.     foreach ($aamaps as $aamap) {
  205.       try {
  206.         $aamapID = $this->getID($aamap);
  207.       }
  208.       catch (PDOException $e) {
  209.         if ($this->enableTransactions)
  210.           $this->pdo->rollBack();
  211.  
  212.         throw $e;
  213.       }
  214.  
  215.       if ($aamapID) {
  216.         $aamapIDs[] = $aamapID;
  217.         $aamap->ID = $aamapID;
  218.       }
  219.       else {
  220.         $ID = $aamap->ID;
  221.         $articleID = $aamap->articleID;
  222.         $authorID = $aamap->authorID;
  223.         $created = $aamap->getCreated()->format('Y-m-d H:i:s');
  224.         $modified = $aamap->getModified()->format('Y-m-d H:i:s');
  225.  
  226.         $stmt->bindParam(':ID', $ID);
  227.         $stmt->bindParam(':articleID', $articleID);
  228.         $stmt->bindParam(':authorID', $authorID);
  229.         $stmt->bindParam(':created', $created);
  230.         $stmt->bindParam(':modified', $modified);
  231.         $result = $stmt->execute();
  232.         OnpubDatabase::verifyExecute($this->pdo, $result, $this->enableTransactions, $stmt->errorInfo());
  233.  
  234.         $aamapIDs[] = $this->pdo->lastInsertId();
  235.         $aamap->ID = $this->pdo->lastInsertId();
  236.       }
  237.     }
  238.  
  239.     if ($this->enableTransactions) {
  240.       $status = $this->pdo->commit();
  241.       OnpubDatabase::verifyTransaction($this->pdo, $status);
  242.     }
  243.  
  244.     if ($isArray) {
  245.       return $aamapIDs;
  246.     }
  247.     else {
  248.       return end($aamapIDs);
  249.     }
  250.   }
  251. }
  252. ?>

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