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

Source for file Site.php

Documentation is available at Site.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. /** Carica la classe base di MCMS per l'interfacciamento al Database */
  27. require_once $_SERVER["DOCUMENT_ROOT"]."/admin/lib/model/Engine.php";
  28. /**
  29.  * Carica la classe per le notizie (News)
  30.  */
  31. require_once $_SERVER["DOCUMENT_ROOT"]."/admin/lib/model/News.php";
  32. /**
  33.  * Carica la classe per gli autori (Author)
  34.  */
  35. require_once $_SERVER["DOCUMENT_ROOT"]."/admin/lib/model/Author.php";
  36. /**
  37.  * Carica la classe per gli articoli (Article)
  38.  */
  39. require_once $_SERVER["DOCUMENT_ROOT"]."/admin/lib/model/Article.php";
  40. /**
  41.  * Carica la classe per le categorie di articoli (Category)
  42.  */
  43. require_once $_SERVER["DOCUMENT_ROOT"]."/admin/lib/model/Category.php";
  44. /**
  45.  * Carica la classe per i componenti (Component)
  46.  */
  47. require_once $_SERVER["DOCUMENT_ROOT"]."/admin/lib/model/Component.php";
  48. /**
  49.  * Carica la classe per le homepages (Homepages)
  50.  */
  51. require_once $_SERVER["DOCUMENT_ROOT"]."/admin/lib/model/Homepage.php";
  52.  
  53. /**
  54.  * Interfaccia per la gestione dei siti gestiti da MCMS.
  55.  *
  56.  * Permette di gestire un sito con tutto il suo contenuto
  57.  * informativo in maniera trasparente rispetto al Database
  58.  * sottostante.
  59.  * 
  60.  * @package  MCMS
  61.  * @version 2
  62.  * @author   Silvio Moioli <silvio at moioli dot net>
  63.  *
  64.  */
  65. class Site extends PEAR
  66. {
  67.     //Attributi
  68.         /**
  69.      * @var int $ID ID del database sottostante per questo sito.
  70.      */
  71.     var $ID = 0;
  72.     /**
  73.      * @var Engine il motore del database sottostante per questo sito.
  74.      */
  75.     var $engine = NULL;
  76.  
  77.     //Costruttori   
  78.         /**
  79.      * Costruttore di lettura
  80.      *
  81.      * Costruttore "di lettura" (costruisce un sito da un record del
  82.      * database già esistente).
  83.      * Nota: non può essere creato una nuovo sito da qui, ma solo dal Factory
  84.      * Method nella classe Engine.
  85.      * Per i costruttori "di scrittura", quindi, vedere la classe Engine
  86.      * nel file Engine.php.
  87.      *
  88.      * @param int $ID l'ID del database sottostante
  89.      * @param Engine $engine un motore per interagire con il database
  90.      *  sottostante
  91.      * @return mixed la pagina se la costruzione è andata a buon fine, altrimenti
  92.      *  un PEAR_Error
  93.      * @see Engine
  94.      */
  95.     function Site($ID$engine)
  96.     {
  97.         if (settype($ID"integer"&& $ID>0){
  98.              $this->ID = $ID;
  99.              $this->engine = $engine;
  100.         }
  101.     }
  102.     
  103.     //Metodi
  104.         /**
  105.      * Ritorna l'ID di questo sito.
  106.      * 
  107.      * Solo le classi del package MCMS potrebbero avere bisogno di
  108.      * questo parametro, per le interrogazioni al Database.
  109.      *
  110.      * @access protected
  111.      * @return int l'ID del database sottostante
  112.      */
  113.      function getID()
  114.      {
  115.          return $this->ID;
  116.      }
  117.      
  118.     /**
  119.      * Ritorna il motore sottostante a questo sito.
  120.      * 
  121.      * Solo le classi del package MCMS potrebbero avere bisogno di
  122.      * questo parametro, per le interrogazioni al Database.
  123.      *
  124.      * @access protected
  125.      * @return int l'ID del database sottostante
  126.      */
  127.      function getEngine()
  128.      {
  129.          return $this->engine;
  130.      }
  131.      
  132.     /**
  133.      * Ritorna le notizie memorizzate in questo Database.
  134.      * 
  135.      * Ritorna un array contenente gli oggetti corrispondenti a tutte le
  136.      * notizie contenute in questo Database per questo sito.
  137.      *
  138.      * @param Category la categoria delle notizie da ritornare o NULL
  139.      *  per tutte indistintamente.
  140.      * @return mixed un array contenente le notizie in questo Database se
  141.      *  l'operazione è andata a buon fine, altrimenti un DB_ERROR.
  142.      * @see News
  143.      */
  144.      function getNews()
  145.      {
  146.         $thisEngine $this->getEngine();
  147.         $thisDB $thisEngine->getDB();
  148.         $siteID $thisDB->escapeSimple($this->getID());
  149.         //Versione con subqueries (mysql 4.1)
  150.         /*$ids = $thisDB->getCol(
  151.             "SELECT `id pagina` FROM `pagine` WHERE `id pagina` IN (SELECT ".
  152.             "`id pagina` FROM `notizie`) AND `id sito`='$siteID' ORDER BY ".
  153.             "`data pagina` DESC;");*/
  154.         //Versione compatibile Mysql 3
  155.         $ids $thisDB->getCol(
  156.             "SELECT `pagine`.`id pagina` FROM `pagine`,`notizie`".
  157.             "WHERE `pagine`.`id pagina`=`notizie`.`id pagina` AND".
  158.             "`pagine`.`id sito`='$siteIDORDER BY ".
  159.             "`pagine`.`data pagina` DESC;");
  160.         #$thisDB->disconnect();
  161.         
  162.         $news array();
  163.         foreach ($ids as $i{
  164.             $news[new News($i$thisEngine);
  165.         }
  166.  
  167.         return $news;
  168.      }
  169.      
  170.     /**
  171.      * Aggiunge una notizia alle notizie memorizzate in questo Database
  172.      * (Factory Method).
  173.      * 
  174.      * Crea una nuova notizia e la memorizza nel Database sottostante.
  175.      * Questo è l'unico modo per creare un notizia!
  176.      *
  177.      * @param Author $author l'autore della notizia (di questo sito)
  178.      * @param string $contents il contenuto HTML di questa pagina.
  179.      * @param string $title il titolo di questa pagina.
  180.      * @param string $keywords l'elenco separato da virgole e spazi
  181.      *  (per esempio "case, amici") delle parole chiave della pagina.
  182.      * @param string $source l'URL della fonte principale di questa notizia o NULL
  183.      * @param array $correlatedArticles un array di Article correlati a
  184.      *  questo articolo.
  185.      * @return mixed la notizia se l'operazione è andata a buon fine, altrimenti
  186.      *  un DB_ERROR
  187.      * @see Author
  188.      * @see News
  189.      * @see Article
  190.      */
  191.      function addNews($author$contents$title$keywords$source,
  192.                          $correlatedArticles)
  193.      {
  194.         //Creo la pagina associata
  195.         $newPage $this->addPage($author$contents$title,
  196.                                     $keywords);
  197.         $thisEngine $this->getEngine();
  198.         $thisDB $thisEngine->getDB();
  199.         $source $thisDB->escapeSimple($source);
  200.         $pageID $thisDB->escapeSimple($newPage->getID());
  201.         
  202.         //Crea e immette il nuovo record per la notizia
  203.         $sql "INSERT INTO `notizie` ( `id pagina` , `url fonte notizia` ) ".
  204.                " VALUES ( '$pageID', '$source' );";
  205.         $thisDB->query($sql);
  206.         
  207.         #$thisDB->disconnect();
  208.                 
  209.         $newNotizia new News($pageID$thisEngine);
  210.         
  211.         //Crea e immette i nuovi record per gli articoli correlati
  212.         foreach ($correlatedArticles as $i{
  213.            $newNotizia->addCorrelatedArticle($i);
  214.         }
  215.  
  216.         return $newNotizia;
  217.      }
  218.  
  219.     /**
  220.      * Cancella una delle notizie tra quelle memorizzate in questo Database.
  221.      * 
  222.      * Cancella una notizia memorizzata nel Database sottostante, incluso tutto
  223.      * il suo contenuto.
  224.      *
  225.      * @param News $news la notizia da cancellare.
  226.      * @return mixed true se l'operazione è andata a buon fine, altrimenti
  227.      *  un DB_ERROR
  228.      * @see News
  229.      */
  230.      function dropNews($news)
  231.      {      
  232.         //Cancella le correlazioni che coinvolgono questa
  233.         //notizia
  234.         $news->dropCorrelatedArticles();
  235.         
  236.         $thisEngine $this->getEngine();
  237.         $thisDB $thisEngine->getDB();
  238.         $pageID $thisDB->escapeSimple($news->getID());
  239.  
  240.         //Cancella la notizia stessa
  241.         $sql "DELETE FROM `notizieWHERE `id pagina` ='$pageID';";
  242.         $thisDB->query($sql);
  243.         #$thisDB->disconnect();        
  244.         
  245.         //Cancella la pagina associata
  246.         $page new Page($pageID$thisEngine);
  247.         $this->dropPage($page);
  248.  
  249.         return true;
  250.     }
  251.      
  252.      /**
  253.      * Cancella tutte le notizie di questo sito.
  254.      * 
  255.      * Cancella tutte le notizie memorizzate nel Database sottostante,
  256.      * per questo sito, incluso tutto il suo contenuto.
  257.      *
  258.      * @return mixed true se l'operazione è andata a buon fine, altrimenti
  259.      *  un DB_ERROR
  260.      * @see News
  261.      */
  262.      function dropAllNews()
  263.      {
  264. /*         $thisEngine = $this->getEngine();
  265.         $thisDB = $thisEngine->getDB();
  266.         $thisEngine = $this->getEngine();
  267.         $siteID = $this->getID();
  268.         $thisDB = $thisEngine->getDB();
  269.         $newsID = $news->getID();
  270.         
  271.         //Cancella le correlazioni fra notizie e articoli
  272.         //di questo sito
  273.         $sql = "DELETE FROM `articoli correlati notizia` WHERE `id notizia`".
  274.                "IN (SELECT `id pagina` FROM `pagine` WHERE".
  275.                "`id sito`='$siteID');";
  276.         $thisDB->query($sql);
  277.         
  278.         //Cancella i record delle notizie
  279.         $sql = "DELETE FROM `notizie` WHERE `id pagina` IN ".
  280.                "(SELECT `id pagina` FROM `pagine` WHERE `id sito`='$siteID');";
  281.         $thisDB->query($sql);
  282. */
  283.  
  284.         $notizie $this->getNews();
  285.         
  286.         foreach ($notizie as $i{
  287.             $this->dropNews($i);
  288.         }
  289.  
  290.        
  291.         //#$thisDB->disconnect();
  292.  
  293.         return true;
  294.      }
  295.     
  296.     /**
  297.      * Ritorna gli articoli memorizzati in questo Database.
  298.      * 
  299.      * Ritorna un array contenente gli oggetti corrispondenti a tutti gli
  300.      * articoli contenuti in questo Database per questo sito.
  301.      *
  302.      * @return mixed un array contenente gli articoli in questo Database se
  303.      *  l'operazione è andata a buon fine, altrimenti un DB_ERROR
  304.      * @see Article
  305.      */
  306.      function getArticles()
  307.      {
  308.         $thisEngine $this->getEngine();
  309.         $thisDB $thisEngine->getDB();
  310.         $siteID $thisDB->escapeSimple($this->getID());
  311.         //Versione con subqueries (Mysql 4.1)
  312.         /*$ids = $thisDB->getCol(
  313.             "SELECT `id pagina` FROM `pagine` WHERE `id pagina` IN (SELECT ".
  314.             "`id pagina` FROM `articoli`) AND `id sito`='$siteID' ORDER BY ".
  315.             "`data pagina` DESC;");*/
  316.         //Versione compatibile Mysql 3
  317.         $ids $thisDB->getCol(
  318.             "SELECT `pagine`.`id pagina` FROM `pagine`,`articoli`".
  319.             "WHERE `pagine`.`id pagina`=`articoli`.`id pagina` AND ".
  320.             "`pagine`.`id sito`='$siteIDORDER BY ".
  321.             "`pagine`.`data pagina` DESC;");
  322.         #$thisDB->disconnect();
  323.         
  324.         $articles array();
  325.         foreach ($ids as $i{
  326.             $articles[new Article($i$thisEngine);
  327.         }
  328.         
  329.         return $articles;
  330.      }
  331.      
  332.     /**
  333.      * Aggiunge un articolo agli articoli memorizzati in questo Database
  334.      * (Factory Method).
  335.      * 
  336.      * Crea un nuovo articolo e lo memorizza nel Database sottostante.
  337.      * Questo è l'unico modo per creare un articolo!
  338.      *
  339.      * @param Author $author l'autore dell'articolo.
  340.      * @param string $contents il contenuto HTML di questa pagina.
  341.      * @param string $title il titolo di questa pagina.
  342.      * @param string $keywords l'elenco separato da virgole e spazi
  343.      *  (per esempio "case, amici") delle parole chiave della pagina.
  344.      * @param Category $category la categoria di appartenenza di questo
  345.      *  articolo
  346.      * @param string $description una breve descrizione dei contenuti
  347.      * @param array $correlatedArticles un array di Article correlati a
  348.      *  questo articolo
  349.      * @return mixed l'articolo se l'operazione è andata a buon fine,
  350.      *  altrimenti un DB_ERROR
  351.      * @see Author
  352.      * @see Article
  353.      * @see Category
  354.      */
  355.      function addArticle($author$contents$title$keywords$category,
  356.                           $description$correlatedArticles)
  357.      {       
  358.         //Creo la pagina associata
  359.         $newPage $this->addPage($author$contents$title,
  360.                                     $keywords);
  361.                                     
  362.         $thisEngine $this->getEngine();
  363.         $thisDB $thisEngine->getDB();
  364.         $description $thisDB->escapeSimple($description);
  365.         $pageID $thisDB->escapeSimple($newPage->getID());
  366.         $categoryID $thisDB->escapeSimple($category->getID());
  367.         
  368.         //Crea e immette il nuovo record per l'articolo
  369.         $sql "INSERT INTO `articoli` ( `id pagina` , `id categoria` ,".
  370.                "`descrizione articolo` )".
  371.                "VALUES ( '$pageID', '$categoryID', '$description' );";
  372.         $thisDB->query($sql);
  373.         #$thisDB->disconnect();
  374.         
  375.         //Crea il nuovo oggetto corrispondente a questo articolo
  376.         $newArticle new Article($pageID$thisEngine);
  377.         
  378.         //Lo correlo agli articoli specificati
  379.         foreach ($correlatedArticles as $i{
  380.            $newArticle->addCorrelatedArticle($i);
  381.         }
  382.         
  383.         return $newArticle;
  384.      }
  385.  
  386.     /**
  387.      * Cancella uno degli articoli tra quelli memorizzati in questo Database.
  388.      * 
  389.      * Cancella un articolo memorizzato nel Database sottostante, incluso tutto
  390.      * il suo contenuto.
  391.      *
  392.      * @param Article $article l'articolo da cancellare.
  393.      * @return mixed true se l'operazione è andata a buon fine, altrimenti
  394.      *  un DB_ERROR
  395.      * @see Article
  396.      */
  397.      function dropArticle($article)
  398.      {
  399.         //Cancella le correlazioni che coinvolgono questo
  400.         //articolo
  401.         $article->dropCorrelatedArticles();
  402.         
  403.         $thisEngine $this->getEngine();
  404.         $category $article->getCategory();
  405.  
  406.         //Cancella l'articolo stesso 
  407.         $thisDB $thisEngine->getDB();
  408.         $pageID $thisDB->escapeSimple($article->getID());
  409.         $categoryID $thisDB->escapeSimple($category->getID());
  410.         $sql "DELETE FROM `articoliWHERE `id pagina` ='$pageID';";
  411.         $thisDB->query($sql);
  412.         #$thisDB->disconnect();
  413.         
  414.         //Cancella la pagina associata
  415.         $page new Page($pageID$thisEngine);
  416.         $this->dropPage($page);
  417.                
  418.         return true;
  419.     }
  420.     
  421.     /**
  422.      * Cancella tutti gli articoli di questo sito.
  423.      * 
  424.      * Cancella tutti gli articoli memorizzati nel Database sottostante
  425.      * per questo sito, incluso tutto il loro contenuto.
  426.      *
  427.      * @return mixed true se l'operazione è andata a buon fine, altrimenti
  428.      *  un DB_ERROR
  429.      * @see Article
  430.      */
  431.      function dropArticles()
  432.      {
  433. /*         $thisEngine = $this->getEngine();
  434.         $thisDB = $thisEngine->getDB();
  435.         $thisEngine = $this->getEngine();
  436.         $siteID = $this->getID();
  437.         $thisDB = $thisEngine->getDB();
  438.         
  439.         //Cancella le correlazioni con altri articoli
  440.         //di questo sito
  441.         $sql = "DELETE FROM `articoli correlati articolo` WHERE `id articolo`".
  442.                "IN (SELECT `id pagina` FROM `pagine` WHERE".
  443.                "`id sito`='$siteID');";
  444.         $thisDB->query($sql);
  445.         $sql = "DELETE FROM `articoli correlati articolo` WHERE `id articolo ".
  446.                "correlato` IN (SELECT `id pagina` FROM `pagine` WHERE".
  447.                "`id sito`='$siteID');";
  448.         $thisDB->query($sql);
  449.         
  450.         //Cancella le correlazioni fra notizie e articoli
  451.         //di questo sito
  452.         $sql = "DELETE FROM `articoli correlati notizia` WHERE `id articolo`".
  453.                "IN (SELECT `id pagina` FROM `pagine` WHERE".
  454.                "`id sito`='$siteID');";
  455.         $thisDB->query($sql);
  456.         
  457.         //Cancella i record degli articoli
  458.         $sql = "DELETE FROM `articoli` WHERE `id pagina` IN ".
  459.                "(SELECT `id pagina` FROM `pagine` WHERE `id sito`='$siteID');";
  460.         $thisDB->query($sql);
  461. */
  462.         
  463.         $articles $this->getArticles();
  464.         
  465.         foreach ($articles as $i{
  466.             $this->dropArticle($i);
  467.         }
  468.       
  469. //        #$thisDB->disconnect();
  470.  
  471.         return true;
  472.      }
  473.  
  474.     /**
  475.      * Ritorna tutte le categorie di questo sito.
  476.      * 
  477.      * Ritorna un array contenente tutte le categorie del sito.
  478.      *
  479.      * @return mixed un array contenente le categorie (Category) se
  480.      *  l'operazione è andata a buon fine, altrimenti un DB_ERROR
  481.      * @see Category
  482.      */
  483.      function getCategories()
  484.      {
  485.         $thisEngine $this->getEngine();
  486.         $thisDB $thisEngine->getDB();
  487.         $siteID $thisDB->escapeSimple($this->getID());
  488.         $ids $thisDB->getCol("SELECT `id categoria` FROM `categorie`".
  489.             " WHERE (`id sito`='$siteID');");
  490.                
  491.         $categories array();
  492.         foreach ($ids as $i{
  493.             $categories[new Category($i$thisEngine);
  494.         }
  495.  
  496.         return $categories;
  497.      }
  498.      
  499.     /**
  500.      * Ritorna il numero di categorie di questo sito.
  501.      * 
  502.      * @return int il numero di categorie
  503.      * @see Category
  504.      */
  505.      function getCategoriesCount()
  506.      {
  507.         $thisEngine $this->getEngine();
  508.         $thisDB $thisEngine->getDB();
  509.         $siteID $thisDB->escapeSimple($this->getID());
  510.         $result $thisDB->getOne("SELECT COUNT(`id categoria`) FROM `categorie`".
  511.             " WHERE (`id sito`='$siteID');");
  512.                
  513.         return $result;
  514.      }
  515.      
  516.     /**
  517.      * Aggiunge una categoria alle categorie memorizzate in questo Database
  518.      * (Factory Method).
  519.      * 
  520.      * Crea una nuova categoria e la memorizza nel Database sottostante.
  521.      * Questo è l'unico modo per creare un categoria!
  522.      *
  523.      * @param string $name il nome della categoria
  524.      * @param string $description breve descrizione del tipo di articoli
  525.      *  nella categoria
  526.      * @return mixed la categoria se l'operazione è andata a buon fine,
  527.      *  altrimenti un DB_ERROR
  528.      * @see Category
  529.      */
  530.      function addCategory($name$description)
  531.      {
  532.         $thisEngine $this->getEngine();
  533.         $thisDB $thisEngine->getDB();
  534.         $name $thisDB->escapeSimple($name);
  535.         $description $thisDB->escapeSimple($description);
  536.         $siteID $thisDB->escapeSimple($this->getID());
  537.         
  538.         $newCategoryID $thisDB->nextID("ID categoria");
  539.         $sql "INSERT INTO `categorie` ( `id categoria` , `nome categoria`,".
  540.                "`descrizione categoria`, `id sito` ) VALUES ".
  541.                "('$newCategoryID', '$name', '$description','$siteID');";
  542.                
  543.         $thisDB->query($sql);
  544.         
  545.         #$thisDB->disconnect();
  546.  
  547.         return new Category($newCategoryID$thisEngine);
  548.      }
  549.  
  550.     /**
  551.      * Cancella una delle categorie tra quelle memorizzate in questo Database.
  552.      * 
  553.      * Cancella una categoria memorizzata nel Database sottostante, inclusi tutti
  554.      * gli articoli in essa contenuti.
  555.      *
  556.      * @param Category $category la categoria da cancellare.
  557.      * @return mixed true se l'operazione è andata a buon fine, altrimenti
  558.      *  un DB_ERROR
  559.      * @see Category
  560.      */
  561.      function dropCategory($category)
  562.      {
  563.         $thisEngine $this->getEngine();
  564.         $thisDB $thisEngine->getDB();
  565.         $categoryID $thisDB->escapeSimple($category->getID());
  566.        
  567.         $sql "DELETE FROM `categorieWHERE `id categoria` ='$categoryID'".
  568.                ";";
  569.         $thisDB->query($sql);
  570.                 
  571.         #$thisDB->disconnect();
  572.  
  573.         return true;
  574.      }
  575.      
  576.     /**
  577.      * Ritorna i componenti utilizzati in questo sito.
  578.      * 
  579.      * Ritorna un array contenente gli oggetti corrispondenti a tutti i
  580.      * componenti utilizzati in questo sito.
  581.      *
  582.      * @return mixed un array contenente gli componenti idi questo sito se
  583.      *  l'operazione è andata a buon fine, altrimenti un DB_ERROR
  584.      * @see Component
  585.      */
  586.      function getComponents()
  587.      {
  588.          $thisEngine $this->getEngine();
  589.          $thisDB $thisEngine->getDB();
  590.          $siteID $thisDB->escapeSimple($this->getID());
  591.          $names $thisDB->getCol("SELECT `nome componente` FROM `componenti siti`".
  592.                                 " WHERE `id sito` = '$siteID';");
  593.          #$thisDB->disconnect();
  594.  
  595.          $components array();
  596.          foreach ($names as $i{
  597.              require_once $_SERVER["DOCUMENT_ROOT"]."/admin/lib/plugins/$i.php";
  598.              //Costruisco il componente
  599.              $components[new $i();
  600.          }
  601.  
  602.          return $components;
  603.      }
  604.  
  605.     /**
  606.      * Sostituisce i componenti attivati in questo sito con quelli
  607.      * specificati nell'array passato.
  608.      *
  609.      * @param array $components i componenti aggiuntivi.
  610.      * @return mixed true se l'operazione è andata a buon fine,
  611.      *  altrimenti un DB_ERROR
  612.      * @see Component
  613.      */
  614.      function changeComponents($components)
  615.      {
  616.          $thisEngine $this->getEngine();
  617.          $thisDB $thisEngine->getDB();
  618.          $siteID $thisDB->escapeSimple($this->getID());
  619.          //Cancella i componenti preesistenti
  620.          $thisDB->query("DELETE FROM `componenti siti` WHERE ".
  621.                             "`id sito` = '$siteID';");
  622.  
  623.          //Immette i nuovi componenti
  624.          foreach ($components as $i{
  625.              $componentName $thisDB->escapeSimple(get_class($i));
  626.              $thisDB->query("INSERT INTO `componenti siti` (`nome componente`,".
  627.              "`id sito`) VALUES ('$componentName', '$siteID');");
  628.          }
  629.  
  630.          #$thisDB->disconnect();
  631.          return true;
  632.      }
  633.  
  634.     /**
  635.      * Getter per il campo URL dalla tabella Sito.
  636.      *
  637.      * Ritorna l'URL di accesso alla homepage del sito.
  638.      *
  639.      * @return mixed l'URL del sito (string) se l'operazione è andata a
  640.      *  buon fine, altrimenti un DB_ERROR
  641.      */
  642.      function getURL()
  643.      {
  644.         $thisEngine $this->getEngine();
  645.         $thisDB $thisEngine->getDB();
  646.         $siteID $thisDB->escapeSimple($this->getID());
  647.         $url $thisDB->getOne("SELECT `url sito` FROM `siti` WHERE ".
  648.                                "`id sito` = '$siteIDLIMIT 1;");
  649.  
  650.         #$thisDB->disconnect();
  651.         return $url;
  652.      }
  653.      
  654.     /**
  655.      * Ritorna una versione "corta" dell'URL del sito.
  656.      *
  657.      * Ritorna una versione "corta" dell'URL del sito, rimuovendo il protocollo
  658.      * ("http://"), l'host www se presente e tutto ciò che segue la prima barra
  659.      * rovesciata, se presente. Ad esempio dall'URL
  660.      * "http://www.moioli.net/index.html" si ottiene "moioli.net".
  661.      *
  662.      * @return mixed l'URL corta del sito (string) se l'operazione è andata a
  663.      *  buon fine, un DB_ERROR se c'è un problema nel DB o l'URL completo se è
  664.      *  impossibile accorciarlo ulteriormente
  665.      */
  666.      function getShortURL()
  667.      {
  668.         $longURL $this->getURL();
  669.         
  670.         $matches array("","");
  671.         preg_match("#http(?:s)?://(?:www\.)?([^/]+)#"$longURL$matches);
  672.         
  673.         //Errore in agguato qui, ma stiamo sulla difensiva
  674.         if ($matches[1]==null || $matches[1]==""{
  675.             print "Site name invalid$longURL";
  676.             return $longURL;
  677.         }
  678.         else {
  679.             return $matches[1];
  680.         }
  681.      }
  682.  
  683.     /**
  684.      * Setter per il campo URL dalla tabella Sito.
  685.      *
  686.      * Cambia l'URL di accesso alla homepage del sito.
  687.      *
  688.      * @param string $URL il nuovo URL del sito
  689.      * @return mixed true se l'operazione è andata a buon fine, altrimenti
  690.      *  un DB_ERROR
  691.      */
  692.      function setURL($URL)
  693.      {
  694.         $thisEngine $this->getEngine();
  695.         $thisDB $thisEngine->getDB();
  696.         $siteID $thisDB->escapeSimple($this->getID());
  697.         $URL $thisDB->escapeSimple($URL);
  698.         
  699.         $thisDB->query("UPDATE `sitiSET `url sito` = '$URL'".
  700.                        "WHERE `id sito` = '$siteID';");
  701.         
  702.         #$thisDB->disconnect();
  703.         return true;
  704.      }
  705.      
  706.     /**
  707.      * Getter per il campo Homepage dalla tabella Sito.
  708.      * 
  709.      * Ritorna l'homepage del sito.
  710.      *
  711.      * @return mixed l'homepage del sito (Homepage) se l'operazione è andata
  712.      *  a buon fine, altrimenti un DB_ERROR
  713.      */
  714.      function getHomepage()
  715.      {
  716.         $thisEngine $this->getEngine();
  717.         $thisDB $thisEngine->getDB();
  718.         $siteID $thisDB->escapeSimple($this->getID());
  719.         //Versione con subqueries (Mysql 4.1)
  720.         /*$sql = "SELECT `id pagina` FROM `homepages` WHERE `id pagina` IN (".
  721.                "SELECT `id pagina` FROM `pagine` WHERE `id sito` = '$siteID');";*/
  722.         //Versione compatibile Mysql 3
  723.         $sql "SELECT `pagine`.`id pagina` FROM `pagine`,`homepages`".
  724.             "WHERE `pagine`.`id pagina`=`homepages`.`id pagina` AND".
  725.             "`pagine`.`id sito`='$siteIDLIMIT 1";
  726.                
  727.         $hpID $thisDB->getOne($sql);
  728.         
  729.         #$thisDB->disconnect();
  730.  
  731.         return new Homepage($hpID$thisEngine);
  732.      }
  733.      
  734.     /**
  735.      * Setter per il campo Homepage dalla tabella Sito.
  736.      * 
  737.      * Cambia l'homepage del sito.
  738.      *
  739.      * @param Homepage $homepage la nuova homepage del sito
  740.      * @return mixed true se l'operazione è andata a buon fine, altrimenti
  741.      *  un DB_ERROR
  742.      */
  743.  //    function setHomepage($homepage)
  744.  //    {
  745.  //    }
  746.      
  747.          
  748.     /**
  749.      * Aggiunge una pagina alle quelle memorizzate in questo Database
  750.      * (Factory Method).
  751.      * 
  752.      * Crea una nuova pagina e la memorizza nel Database sottostante.
  753.      * Questo è l'unico modo per creare un pagina!
  754.      * Questo metodo dovrebbe essere invocato SOLO dalle classi interne
  755.      * di MCMS, per la costruzione di Articoli, Notizie e Homepages.
  756.      *
  757.      * @access private
  758.      * @param Author $author l'autore della nuova pagina
  759.      * @param string $contents il contenuto HTML della pagina
  760.      * @param string $title il titolo della pagina
  761.      * @param string $keywords l'elenco separato da virgole e spazi
  762.      *  (per esempio "case, amici") delle parole chiave della pagina.
  763.      * @return mixed la pagina se l'operazione è andata a buon fine,
  764.      *  altrimenti un DB_ERROR
  765.      * @see Page
  766.      */
  767.      function addPage($author$contents$title$keywords)
  768.      {
  769.         $thisEngine $this->getEngine();
  770.         $thisDB $thisEngine->getDB();
  771.         $pageID $thisDB->nextID("id pagina");
  772.         $siteID $thisDB->escapeSimple($this->getID());
  773.         $authorID $thisDB->escapeSimple($author->getID());
  774.         $contents $thisDB->escapeSimple($contents);
  775.         $title $thisDB->escapeSimple($title);
  776.         $keywords $thisDB->escapeSimple($keywords);
  777.  
  778.  
  779.         $today date("Y:m:d");
  780.         //Inserisce la nuova pagina
  781.         $sql "INSERT INTO `pagine` ( `id pagina` , `id sito` , `id autore`,".
  782.                "`contenuto pagina` , `data pagina` , `titolo pagina` ,".
  783.                "`parole chiave pagina` )".
  784.                "VALUES ( '$pageID', '$siteID', '$authorID', '$contents',".
  785.                "'$today', '$title', '$keywords');";
  786.         $thisDB->query($sql);
  787.         
  788.         #$thisDB->disconnect();
  789.         return new Page($pageID$thisEngine);
  790.      }
  791.      
  792.     /**
  793.      * Cancella una delle pagine memorizzate in questo Database.
  794.      * 
  795.      * Cancella una pagina memorizzata nel Database sottostante, con tutto il
  796.      * suo contenuto informativo. ATTENZIONE: questo NON elimina l'articolo,
  797.      * la notizia o l'homepage associata!
  798.      *
  799.      * @access private
  800.      * @param Page $page la pagina da cancellare.
  801.      * @return mixed true se l'operazione è andata a buon fine, altrimenti
  802.      *  un DB_ERROR
  803.      * @see Page
  804.      */
  805.      function dropPage($page)
  806.      {        
  807.         $thisEngine $this->getEngine();
  808.         $thisDB $thisEngine->getDB();
  809.         $pageID $thisDB->escapeSimple($page->getID());
  810.        
  811.         $sql "DELETE FROM `pagineWHERE `id pagina` ='$pageID';";
  812.         
  813.         $thisDB->query($sql);
  814.         
  815.         #$thisDB->disconnect();
  816.         return true;
  817.      }
  818.      
  819.     /**
  820.      * Cancella le pagine di questo sito.
  821.      * 
  822.      * Cancella tutte le pagine memorizzate per questo sito, inclusi articoli,
  823.      * notizie e homepage. Questo metodo dovrebbe essere chiamato solo da
  824.      * un metodo che cancella anche questo sito.
  825.      *
  826.      * @access private
  827.      * @return mixed true se l'operazione è andata a buon fine, altrimenti
  828.      *  un DB_ERROR
  829.      * @see Page
  830.      */
  831.      function dropPages()
  832.      {
  833.         
  834.         //Cancella articoli e notizie
  835.         $this->dropArticles();
  836.         $this->dropAllNews();
  837.         
  838.         $thisEngine $this->getEngine();
  839.         $thisDB $thisEngine->getDB();
  840.         $siteID $thisDB->escapeSimple($this->getID());
  841.         
  842.         //Cancella la homepage
  843.         //$sql = "DELETE FROM `homepages` WHERE `id pagina` IN ".
  844.         //       "(SELECT `id pagina` FROM `pagine` WHERE `id sito`='$siteID');";
  845.         //$sql = "DELETE `homepages` FROM `homepages`,`pagine` WHERE ".
  846.         //       "`homepages`.`id pagina`=`pagine`.`id pagina` AND ".
  847.         //       "`pagine`.`id sito`='$siteID';";
  848.         $homeID $thisDB->getOne("SELECT `homepages`.`id pagina` ".
  849.             "FROM `homepages`, `pagine`".
  850.             "WHERE `homepages`.`id pagina`=`pagine`.`id pagina` AND".
  851.             "`pagine`.`id sito`='$siteIDLIMIT 1");
  852.         $thisDB->query("DELETE FROM `homepagesWHERE `id pagina`='$homeID'");
  853.         
  854.         //Cancella le pagine associate
  855.         $sql "DELETE FROM `pagineWHERE `id sito`='$siteID';";
  856.         $thisDB->query($sql);
  857.         
  858.         #$thisDB->disconnect();
  859.  
  860.         return true;
  861.      }
  862.      
  863.     /**
  864.      * Ritorna l'autore fondatore di questo sito.
  865.      * 
  866.      * Ritorna un oggetto corrispondente all'autore principale di questo sito
  867.      * Permette di utilizzare il database in modo trasparente (è come se si
  868.      * usassero normali attributi di una classe).
  869.      *
  870.      * @return Author l'autore a cui questa pagina appartiene.
  871.      * @see Author
  872.      */
  873.      function getAuthor()
  874.      {
  875.         $thisEngine $this->getEngine();
  876.         $thisDB $thisEngine->getDB();
  877.         $thisID $thisDB->escapeSimple($this->getID());
  878.         $hpID $thisDB->getOne(
  879.         "SELECT `id autore`
  880.              FROM `siti`
  881.                  JOIN `pagineON `siti`.`id sito`=`pagine`.`id sito`
  882.                  JOIN `homepagesON `homepages`.`id pagina`=`pagine`.`id pagina`
  883.              WHERE `siti`.`id sito`='$thisIDLIMIT 1;");
  884.         
  885.         #$thisDB->disconnect();
  886.         return new Author($hpID$thisEngine);
  887.      }
  888.      
  889.     /**
  890.      * Ritorna gli autori di questo sito.
  891.      * 
  892.      * Ritorna un array contenente gli autori di questo
  893.      * sito contenuti in questo Database.
  894.      *
  895.      * @return mixed un array contenente i siti in questo Database se
  896.      *          l'operazione è andata a buon fine, altrimenti un DB_ERROR
  897.      * @see Author
  898.      */
  899.      function getAuthors()
  900.      {
  901.         $thisEngine $this->getEngine();
  902.         $thisDB $thisEngine->getDB();
  903.         $siteID $thisDB->escapeSimple($this->getID());
  904.  
  905.         //Versione con subqueries (Mysql 4.1)
  906.         /*$ids = $thisDB->getCol("SELECT `id autore` FROM `autori` WHERE `id autore` ".
  907.                                 "IN (SELECT `id autore` FROM `pagine` WHERE ".
  908.                                 "`id sito`='$siteID');");*/
  909.         //Versione compatibile Mysql 3
  910.         $ids $thisDB->getCol(
  911.             "SELECT DISTINCT `autori`.`id autore` FROM `pagine`,`autori`".
  912.             "WHERE `pagine`.`id autore`=`autori`.`id autore` AND".
  913.             "`pagine`.`id sito`='$siteID'");
  914.         #$thisDB->disconnect();
  915.         $authors array();
  916.         foreach ($ids as $i{
  917.             $authors[new Author($i$thisEngine);
  918.         }
  919.  
  920.         return $authors;
  921.      }
  922. }
  923. ?>

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