MCMS
[ class tree: MCMS ] [ index: MCMS ] [ all elements ]

Source for file Article.php

Documentation is available at Article.php

  1. <?php
  2. /* vim: set expandtab tabstop=4 shiftwidth=4: */
  3. // +----------------------------------------------------------------------+
  4. // | MCMS: a PHP Content Management System for creating accessible sites. |
  5. // | Copyright (C) 2005  Silvio Moioli                                    |
  6. // |                                                                      |
  7. // | This program is free software; you can redistribute it and/or modify |
  8. // | it under the terms of the GNU General Public License as published by |
  9. // | the Free Software Foundation; either version 2 of the License, or    |
  10. // | (at your option) any later version.                                  |
  11. // |                                                                      |
  12. // | This program is distributed in the hope that it will be useful,      |
  13. // | but WITHOUT ANY WARRANTY; without even the implied warranty of       |
  14. // | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        |
  15. // | GNU General Public License for more details.                         |
  16. // |                                                                      |
  17. // | You should have received a copy of the GNU General Public License    |
  18. // | along with this program; if not, write to the Free Software          |
  19. // | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 |
  20. // +----------------------------------------------------------------------+
  21. // | Authors: Silvio Moioli <silvio at moioli dot net> www.moioli.net     |
  22. // +----------------------------------------------------------------------+
  23. //
  24. //$Id:
  25.  
  26. /**
  27.  * Carica la classe per le pagine (Page)
  28.  */
  29. require_once $_SERVER["DOCUMENT_ROOT"]."/admin/lib/model/Page.php";
  30.  
  31. /**
  32.  * Interfaccia per la gestione degli articoli del sito.
  33.  *
  34.  * Permette di utilizzare il database in modo trasparente: creare oggetti
  35.  * di questa classe e operare sugli attributi tramite gli appositi metodi
  36.  * modificherà automaticamente il database sottostante.
  37.  * 
  38.  * @package  MCMS
  39.  * @version  2
  40.  * @author   Silvio Moioli <silvio at moioli dot net>
  41.  */
  42. class Article extends Page
  43. {
  44.     //Attributi ereditati: $ID e $engine
  45.  
  46.     //Costruttori
  47.         /**
  48.      * Costruttore di lettura
  49.      *
  50.      * Costruttore "di lettura" (costruisce un articolo da un record del
  51.      * database già esistente).
  52.      * Nota: non può essere creata una nuova pagina da qui, ma solo dal Factory
  53.      * Method nella classe Site.
  54.      * Per i costruttori "di scrittura", quindi, vedere la classe Site
  55.      * nel file Site.php.
  56.      *
  57.      * @param int $ID l'ID del database sottostante
  58.      * @param Engine $engine un motore per interagire con il database
  59.      *  sottostante
  60.      * @return mixed l'articolo se la costruzione è andata a buon fine, altrimenti
  61.      *          un PEAR_Error
  62.      * @see Engine
  63.      */
  64.     function Article($ID$engine)
  65.     {
  66.         $this->Page($ID$engine);
  67.     }
  68.     
  69.     //Metodi   
  70.         /**
  71.      * Getter per la categoria cui l'articolo appartiene.
  72.      * 
  73.      * Ritorna un oggetto corrispondente alla categoria di appartenenza di
  74.      * questo articolo.
  75.      *
  76.      * @return mixed la categoria (Category) se l'operazione è andata a buon fine, altrimenti
  77.      *          un PEAR_Error
  78.      * @see Category
  79.      */
  80.      function getCategory()
  81.      {
  82.         $thisEngine $this->getEngine();
  83.         $thisDB $thisEngine->getDB();
  84.         $thisID $thisDB->escapeSimple($this->getID());
  85.         $hpID $thisDB->getOne("SELECT `id categoria` FROM `articoli`".
  86.                                 "WHERE `id pagina` = '$thisIDLIMIT 1;");
  87.         
  88.         #$thisDB->disconnect();
  89.         return new Category($hpID$thisEngine);
  90.      }
  91.      
  92.     /**
  93.      * Setter per la categoria cui l'articolo appartiene.
  94.      * 
  95.      * Cambia la categoria cui questo articolo appartiene.
  96.      *
  97.      * @param Category $category la nuova categoria
  98.      * @return mixed true se l'operazione è andata a buon fine, altrimenti
  99.      *          un DB_ERROR
  100.      * @see Category
  101.      */
  102.      function setCategory($category)
  103.      {
  104.         $thisEngine $this->getEngine();
  105.         $thisDB $thisEngine->getDB();
  106.         $thisID $thisDB->escapeSimple($this->getID());
  107.         $newCategoryID $thisDB->escapeSimple($category->getID());
  108.         $thisDB->query("UPDATE `articoliSET `id categoria`='$newCategoryID'".
  109.                        "WHERE `id pagina` = '$thisID';");
  110.         
  111.         #$thisDB->disconnect();
  112.         return true;
  113.      }
  114.  
  115.     /**
  116.      * Getter per la descrizione dell'articolo appartiene.
  117.      * 
  118.      * Ritorna la stringa di riassunto di questo articolo.
  119.      *
  120.      * @return mixed la descrizione (string) se l'operazione è andata a buon fine, altrimenti
  121.      *          un PEAR_Error
  122.      * @see Category
  123.      */
  124.      function getDescription()
  125.      {
  126.         $thisEngine $this->getEngine();
  127.         $thisDB $thisEngine->getDB();
  128.         $thisID $thisDB->escapeSimple($this->getID());
  129.         $res $thisDB->getOne("SELECT `descrizione articolo` FROM `articoli`".
  130.                                 "WHERE `id pagina` = '$thisIDLIMIT 1;");
  131.         
  132.         #$thisDB->disconnect();
  133.         return $res;
  134.      }
  135.      
  136.     /**
  137.      * Setter per la descrizione dell'articolo appartiene.
  138.      * 
  139.      * Cambia la stringa di riassunto di questo articolo.
  140.      *
  141.      * @param string $description la nuova descrizione
  142.      * @return mixed true se l'operazione è andata a buon fine, altrimenti
  143.      *          un DB_ERROR
  144.      * @see Category
  145.      */
  146.      function setDescription($description)
  147.      {
  148.         $thisEngine $this->getEngine();
  149.         $thisDB $thisEngine->getDB();
  150.         $thisID $thisDB->escapeSimple($this->getID());
  151.         $description $thisDB->escapeSimple($thisDB->escapeSimple($description));
  152.         $thisDB->query("UPDATE `articoliSET `descrizione articolo`='$description'".
  153.                        "WHERE `id pagina` = '$thisID';");
  154.         
  155.         #$thisDB->disconnect();
  156.         return true;
  157.      }
  158.      
  159.     /**
  160.      * Getter per gli articoli correlati a questo articolo.
  161.      * 
  162.      * Ritorna un array contenente gli articoli correlati a questo articolo.
  163.      *
  164.      * @return mixed un array di Article se l'operazione è andata a
  165.      *  buon fine o un DB_ERROR in caso di errore
  166.      */
  167.      function getCorrelatedArticles()
  168.      {
  169.         $thisEngine $this->getEngine();
  170.         $thisDB $thisEngine->getDB();
  171.         $articleID $thisDB->escapeSimple($this->getID());
  172.         
  173.         $sql "SELECT `id articolo`
  174.                     FROM `articoli correlati articolo`
  175.                     WHERE `id articolo correlato` ='$articleID'
  176.                 UNION
  177.                     SELECT `id articolo correlato`
  178.                         FROM `articoli correlati articolo`
  179.                         WHERE `id articolo` ='$articleID';";
  180.         $articleIDs $thisDB->getCol($sql);
  181.         #$thisDB->disconnect();
  182.         
  183.         //Creo l'array degli oggetti a partire dagli IDs
  184.         $articles array();
  185.         foreach ($articleIDs as $i{
  186.             $articles[new Article($i$thisEngine);
  187.         }
  188.         
  189.         return $articles;
  190.      }
  191.      
  192.     /**
  193.      * Ritorna il numero degli articoli correlati a questo articolo.
  194.      * 
  195.      * @return mixed un int se l'operazione è andata a
  196.      *  buon fine o un DB_ERROR in caso di errore
  197.      */
  198.      function getCorrelatedArticlesCount()
  199.      {
  200.         $thisEngine $this->getEngine();
  201.         $thisDB $thisEngine->getDB();
  202.         $articleID $thisDB->escapeSimple($this->getID());
  203.         
  204.         $sql "SELECT COUNT(`id articolo`) FROM `articoli correlati articolo` WHERE ".
  205.                "`id articolo correlato` ='$articleIDOR `id articolo` ='$articleID';";
  206.         $result $thisDB->getOne($sql);
  207.         
  208.         #$thisDB->disconnect();
  209.         return $result;
  210.      }
  211.     
  212.     /**
  213.      * Correla questo articolo con un altro.
  214.      * 
  215.      * Aggiunge un nuovo articolo fra quelli correlati a questo articolo.
  216.      *
  217.      * @param Article $article l'articolo da aggiungere
  218.      * @return mixed true se l'operazione è andata a buon fine o un
  219.      *  DB_ERROR in caso di errore
  220.      */
  221.      function addCorrelatedArticle($article)
  222.      {
  223.         $thisEngine $this->getEngine();
  224.         $thisDB $thisEngine->getDB();
  225.         $articleID $thisDB->escapeSimple($article->getID());
  226.         $pageID $thisDB->escapeSimple($this->getID());
  227.         $sql "INSERT INTO `articoli correlati articolo` (`id articolo`,".
  228.                "`id articolo correlato` ) VALUES ( '$pageID', '$articleID' );";
  229.         $thisDB->query($sql);
  230.         
  231.  
  232.         #$thisDB->disconnect();
  233.         return true;
  234.      }
  235.      
  236.     /**
  237.      * Rimuove la correlazione tra questo e un altro articolo.
  238.      * 
  239.      * Se tra questo articolo e quello specificato nel parametro c'è
  240.      * correlazione (i due articoli sono correlati per il contenuto
  241.      * fra loro), essa viene rimossa.
  242.      *
  243.      * @param Article $article l'articolo da rimuovere
  244.      * @return mixed true se l'operazione è andata a buon fine o un
  245.      *  DB_ERROR in caso di errore
  246.      */
  247.      function dropCorrelatedArticle($article)
  248.      {
  249.         $thisEngine $this->getEngine();
  250.         $thisDB $thisEngine->getDB();
  251.         $articleAID $thisDB->escapeSimple($this->getID());
  252.         $articleBID $thisDB->escapeSimple($article->getID());
  253.         
  254.         //La relazione potrebbe essere sia da "a" a "b" che
  255.         //viceversa, cancello in ogni caso
  256.         $sql "DELETE FROM `articoli correlati articolo` WHERE".
  257.                "((`id articolo`='$articleAID') AND ".
  258.                " (`id articolo correlato` ='$articleBID')) OR".
  259.                "((`id articolo`='$articleBID') AND ".
  260.                " (`id articolo correlato` ='$articleAID'));";
  261.         $thisDB->query($sql);
  262.         
  263.  
  264.         #$thisDB->disconnect();
  265.         return true;
  266.      }
  267.      
  268.     /**
  269.      * Rimuove tutte le correlazioni che coinvolgono questo articolo.
  270.      * 
  271.      * Se questo articolo ha articoli correlati (o equivalentemente
  272.      * qualsiasi articolo è correlato a questo), le correlazioni
  273.      * vengono eliminate.
  274.      *
  275.      * @return mixed true se l'operazione è andata a buon fine o un
  276.      *  DB_ERROR in caso di errore
  277.      */
  278.      function dropCorrelatedArticles()
  279.      {
  280.         $thisEngine $this->getEngine();
  281.         $thisDB $thisEngine->getDB();
  282.         $articleID $thisDB->escapeSimple($this->getID());
  283.         
  284.         $sql "DELETE FROM `articoli correlati articolo` WHERE".
  285.                "(`id articolo`='$articleID') OR".
  286.                "(`id articolo correlato`='$articleID');";
  287.         $thisDB->query($sql);
  288.         
  289.  
  290.         #$thisDB->disconnect();
  291.         return true;
  292.      }
  293.      
  294.     /**
  295.      * Setter per gli articoli correlati a questo articolo.
  296.      * 
  297.      * Cambia gli articoli correlati a questo articolo con un insieme di altri.
  298.      *
  299.      * @param array $articles i nuovi articoli correlati
  300.      * @return mixed true se l'operazione è andata a buon fine o un DB_ERROR
  301.      *  in caso di errore
  302.      * @see Article
  303.      */
  304.      function setCorrelatedArticles($articles)
  305.      {
  306.          $this->dropCorrelatedArticles();
  307.          foreach ($articles as $i){
  308.              $this->addCorrelatedArticle($i);
  309.          }
  310.          
  311.          return true;
  312.      }
  313.      
  314.     /**
  315.      * Ritorna gli eventuali articoli non correlati ma appartenenti alla
  316.      * stessa categoria.
  317.      *
  318.      * @return mixed un array di Article se l'operazione è andata a buon fine
  319.      *  o un DB_ERROR in caso di errore
  320.      * @see Article
  321.      */
  322.      function getNeighbourArticles()
  323.      {
  324.         $category $this->getCategory();
  325.         $categoryID $category->getID();
  326.         $thisEngine $this->getEngine();
  327.         $thisDB $thisEngine->getDB();
  328.         $articleID $thisDB->escapeSimple($this->getID());
  329.         $categoryID $thisDB->escapeSimple($categoryID);
  330.         
  331. /*        $sql = "SELECT DISTINCT `id pagina`
  332.                     FROM `articoli` JOIN `categorie`
  333.                         ON `articoli`.`id categoria`=`categorie`.`id categoria`
  334.                     WHERE `articoli`.`id categoria`='$categoryID'
  335.                         AND `articoli`.`id pagina`<>'$articleID'
  336.                         AND `articoli`.`id pagina` NOT IN                     
  337.                     (SELECT `id articolo`
  338.                         FROM `articoli correlati articolo`
  339.                         WHERE `id articolo correlato` ='$articleID'
  340.                      UNION
  341.                         SELECT `id articolo correlato`
  342.                             FROM `articoli correlati articolo`
  343.                             WHERE `id articolo` ='$articleID');";*/
  344.  
  345.         $sql "SELECT DISTINCT A1.`id pagina`
  346.                     FROM `articoliAS A1 JOIN `categorie`
  347.                         ON A1.`id categoria`=`categorie`.`id categoria`
  348.                         LEFT JOIN `articoli correlati articoloAS A2
  349.                             ON A2.`id articolo`=A1.`id pagina`
  350.                         LEFT JOIN `articoli correlati articoloAS A3
  351.                             ON A3.`id articolo correlato`=A1.`id pagina`
  352.                     WHERE A1.`id categoria`='$categoryID'
  353.                         AND A1.`id pagina`<>'$articleID'
  354.                         AND COALESCE(A2.`id articolo correlato`,'nessuno')<>'$articleID'
  355.                         AND COALESCE(A3.`id articolo`,'nessuno')<>'$articleID';";
  356.  
  357.         $articleIDs $thisDB->getCol($sql);
  358.         #$thisDB->disconnect();
  359.         
  360.         //Creo l'array degli oggetti a partire dagli IDs
  361.         $articles array();
  362.         foreach ($articleIDs as $i{
  363.             $articles[new Article($i$thisEngine);
  364.         }
  365.         
  366.         return $articles;
  367.      }
  368.      
  369.     /**
  370.      * Ritorna il numero degli articoli non correlati ma appartenenti alla
  371.      * stessa categoria.
  372.      *
  373.      * @return mixed un array di Article se l'operazione è andata a buon fine
  374.      *  o un DB_ERROR in caso di errore
  375.      * @see Article
  376.      */
  377.      function getNeighbourArticlesCount()
  378.      {
  379.         $category $this->getCategory();
  380.         $categoryID $category->getID();
  381.         $thisEngine $this->getEngine();
  382.         $thisDB $thisEngine->getDB();
  383.         $categoryID $thisDB->escapeSimple($categoryID);
  384.         $articleID $thisDB->escapeSimple($this->getID());
  385.                 
  386.         $sql "SELECT COUNT(DISTINCT A1.`id pagina`)
  387.                     FROM `articoliAS A1 JOIN `categorie`
  388.                         ON A1.`id categoria`=`categorie`.`id categoria`
  389.                         LEFT JOIN `articoli correlati articoloAS A2
  390.                             ON A2.`id articolo`=A1.`id pagina`
  391.                         LEFT JOIN `articoli correlati articoloAS A3
  392.                             ON A3.`id articolo correlato`=A1.`id pagina`
  393.                     WHERE A1.`id categoria`='$categoryID'
  394.                         AND A1.`id pagina`<>'$articleID'
  395.                         AND COALESCE(A2.`id articolo correlato`,'nessuno')<>'$articleID'
  396.                         AND COALESCE(A3.`id articolo`,'nessuno')<>'$articleID';";
  397.  
  398.         $result $thisDB->getOne($sql);
  399.         #$thisDB->disconnect();
  400.                
  401.         return $result;
  402.      }
  403. }
  404. ?>

Documentation generated on Wed, 26 Jul 2006 21:44:48 +0200 by phpDocumentor 1.3.0RC6