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

Source for file Engine.php

Documentation is available at Engine.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.  * Interfaccia per la gestione dei dettagli della connessione con il
  27.  * Database sottostante.
  28.  *
  29.  * @package  MCMS
  30.  * @version  2
  31.  * @author   Silvio Moioli <silvio at moioli dot net>
  32.  *
  33.  */
  34.  
  35. /* Questo forza l'interprete PHP ad usare l'installazione di PEAR fornita 
  36. con MCMS. Non sarà un'idea brillantissima, ma permette al tutto di funzionare
  37. senza complicare il processo di installazione, inoltre funziona con i web
  38. hosting senza servizio di shell remota. */
  39. set_include_path($_SERVER["DOCUMENT_ROOT"]."/admin/include/pear/");
  40.  
  41. /** Carica la classe base di PEAR */
  42. require_once $_SERVER["DOCUMENT_ROOT"]."/admin/include/pear/PEAR.php";
  43. /** Carica la classe PEAR::Date */
  44. require_once $_SERVER["DOCUMENT_ROOT"]."/admin/include/pear/Date.php";
  45. /** Carica la classe PEAR::DB */
  46. require_once $_SERVER["DOCUMENT_ROOT"]."/admin/include/pear/DB.php";
  47. /** Carica la classe per gli autori (Author) */
  48. require_once $_SERVER["DOCUMENT_ROOT"]."/admin/lib/model/Author.php";
  49. /** Carica la classe per le categorie di articoli (Category) */
  50. require_once $_SERVER["DOCUMENT_ROOT"]."/admin/lib/model/Category.php";
  51.  
  52. /**
  53.  * Setta la gestione degli errori di PEAR. Questo richiamerà
  54.  * automaticamente die() senza che debba fare controlli.
  55.  */
  56. PEAR::setErrorHandling(PEAR_ERROR_PRINT);
  57.  
  58. /**
  59.  * Interfaccia per la gestione della connessione con il
  60.  * Database sottostante.
  61.  *
  62.  * Permette di utilizzare le classi come MCMS_Pagine, MCMS_Sito, ecc. al posto
  63.  * di interrogazioni al database in modo trasparente.
  64.  * 
  65.  * @package  MCMS
  66.  * @version  2
  67.  * @author   Silvio Moioli <silvio at moioli dot net>
  68.  *
  69.  */
  70. class Engine extends PEAR
  71. {
  72.     //Attributi
  73.         /**
  74.      * @var string $dataSourceName la stringa che specifica nome, posizione,
  75.      *  tipo di connessione, nome utente e password per il database.
  76.      * @see PEAR::DB
  77.      */
  78.     var $dataSourceName = '';
  79.     /**
  80.      * @var PEAR::DB $dbConnection la connessione corrente al DB, se è già stata
  81.      *  inizializzata.
  82.      * @see PEAR::DB
  83.      */
  84.     var $dbConnection = null;
  85.  
  86.     //Costruttori   
  87.         /**
  88.      * Costruttore standard.
  89.      *
  90.      * Costruisce un motore tramite un DataSourceName che permetta la connessione
  91.      * a un DBMS. Se il DBMS non contiene le tabelle necessarie al funzionamento
  92.      * di MCMS, esse verranno create (vuote).
  93.      *
  94.      * @return mixed true se la connessione è andata a buon fine, altrimenti
  95.      *          un DB_ERROR
  96.      * @see PEAR::DB
  97.      */
  98.     function Engine()
  99.     {       
  100.         $this->PEAR();
  101.         
  102.         //Carica il file con la configurazione per il database
  103.         include $_SERVER["DOCUMENT_ROOT"]."/admin/config.php";
  104.  
  105.         //Salva il DSN localmente
  106.         $this->dataSourceName = $dsn;//presa dal file config.php
  107.         
  108.         //Si connette al DB
  109.         $db $this->getDB();
  110.         
  111.         //Controlla se esistono le tabelle di MCMS
  112.         $currentTables $db->getListOf("tables");
  113.         if (in_array("siti"$currentTables== false{
  114.             //Non ci sono tabelle, è ora di crearle
  115.             $this->createTables();
  116.         }
  117.         #$db->disconnect();
  118.     }
  119.     
  120.     //Metodi
  121.         /**
  122.      * Ritorna un oggetto DB valido per lavorare sul database
  123.      * sottostante MCMS.
  124.      * 
  125.      * Ritorna un oggetto DB valido per lavorare sul database
  126.      * sottostante MCMS. Dovrebbe essere usato solo dalle classi
  127.      * di MCMS.
  128.      *
  129.      * @access protected
  130.      * @return mixed un un oggetto DB se l'operazione è andata a buon fine,
  131.      *  altrimenti un DB_ERROR
  132.      * @see Site
  133.      */
  134.      function getDB()
  135.      {
  136.         if ($this->dbConnection!=null){
  137.             return $this->dbConnection;
  138.         }
  139.         else{
  140.             //Si connette al DB
  141.             $options array(
  142.                 'debug'    => 3,
  143.                 'optimize' => 'portability',
  144.             );
  145.         
  146.             //Ritorna il risultato
  147.             $this->dbConnection=DB::connect($this->dataSourceName$options);
  148.             return $this->dbConnection;
  149.         }
  150.      }
  151.      
  152.     /**
  153.      * Chiude la connessione con il database sottostante.
  154.      * 
  155.      * @access protected
  156.      */
  157.      function disconnect()
  158.      {
  159.          $this->dbConnection->disconnect();
  160.      }
  161.      
  162.     /**
  163.      * Ritorna i siti memorizzati in questo Database.
  164.      * 
  165.      * Ritorna un array contenente gli oggetti corrispondenti a tutti i
  166.      * siti contenuti in questo Database.
  167.      *
  168.      * @return mixed un array contenente i siti in questo Database se
  169.      *          l'operazione è andata a buon fine, altrimenti un DB_ERROR
  170.      * @see Site
  171.      */
  172.      function getSites()
  173.      {
  174.          $thisDB $this->getDB();
  175.          $ids $thisDB->getCol("SELECT `id sito` FROM `siti`;");
  176.          
  177.          #$thisDB->disconnect();         
  178.          $sites array();
  179.          foreach ($ids as $i{
  180.              $sites[new Site($i$this);
  181.          }
  182.  
  183.          return $sites;
  184.      }
  185.      
  186.     /**
  187.      * Aggiunge un sito ai siti memorizzati in questo Database
  188.      * (Factory Method).
  189.      * 
  190.      * Crea un nuovo sito e lo memorizza nel Database sottostante, creando
  191.      * anche una homepage vuota. Questo è l'unico modo per creare un sito!
  192.      *
  193.      * @param string $URL l'indirizzo del sito
  194.      * @param string $slogan il motto del sito (es. Clarence: "a wwworld apart")
  195.      * @param Author $author l'autore del sito (e dell'homepage)
  196.      * @param string $keywords l'elenco separato da virgole e spazi
  197.      *  (per esempio "case, amici") delle parole chiave della pagina.
  198.      * @return mixed il sito se l'operazione è andata a buon fine, altrimenti
  199.      *          un DB_ERROR
  200.      * @see Site
  201.      */
  202.      function addSite($URL$slogan$author$keywords)
  203.      {
  204.         //Crea e immette il nuovo record per il sito
  205.         $thisDB $this->getDB();
  206.         $siteID $thisDB->nextID("id sito");
  207.         $URL $thisDB->escapeSimple($URL);
  208.         $slogan $thisDB->escapeSimple($slogan);
  209.         $keywords $thisDB->escapeSimple($keywords);
  210.         $sql "INSERT INTO `siti` ( `id sito` , `url sito` ) "
  211.               ." VALUES ( '$siteID', '$URL');";               
  212.         $thisDB->query($sql);
  213.         #$thisDB->disconnect();
  214.         
  215.         //Crea e immette il nuovo record per la pagina
  216.         $newSite new Site($siteID$this);
  217.         $newPage $newSite->addPage($author"Questo &egrave; il mio nuovo sito!",
  218.                                        $URL$keywords);
  219.         $newPageID $newPage->getID();
  220.         
  221.         //Crea e immette il nuovo record per la homepage
  222.         $thisDB $this->getDB();
  223.         $sql "INSERT INTO `homepages` ( `id pagina` , `motto homepage` ) "
  224.             . " VALUES ( '$newPageID', '$slogan' );";
  225.         $thisDB->query($sql);
  226.         
  227.         #$thisDB->disconnect();
  228.         
  229.         //Crea una categoria vuota
  230.         $newSite->addCategory("Varie""Dentro tutto!");
  231.         
  232.         //Ritorna il nuovo sito felicemente creato
  233.         return $newSite;
  234.      }
  235.  
  236.     /**
  237.      * Cancella un sito ai siti memorizzati in questo Database.
  238.      * 
  239.      * Cancella un sito memorizzato  nel Database sottostante, incluse tutte
  240.      * le pagine e tutti i contenuti.
  241.      *
  242.      * @param Site $site il sito da cancellare
  243.      * @return mixed true se l'operazione è andata a buon fine, altrimenti
  244.      *          un DB_ERROR
  245.      * @see Site
  246.      */
  247.      function dropSite($site)
  248.      {
  249.         //Cancella le pagine del sito
  250.         $site->dropPages();
  251.         
  252.         $thisDB $this->getDB();
  253.         $siteID $thisDB->escapeSimple($site->getID());
  254.         
  255.         //Cancella le relazioni con i componenti
  256.         $sql "DELETE FROM `componenti sitiWHERE `id sito`='$siteID';";
  257.         $thisDB->query($sql);
  258.         
  259.         //Cancella il sito stesso
  260.         $sql "DELETE FROM `sitiWHERE `id sito`='$siteID';";
  261.         $thisDB->query($sql);
  262.         
  263.         //Cancella le categorie vuote (non è bellissimo ma il manuale di MySQL dice
  264.         //di fare così...)
  265.         $ids $thisDB->getCol("SELECT `categorie`.`id categoria` ".
  266.         "FROM `categorie` LEFT JOIN `articoli` ON `categorie`.`id categoria`".
  267.         "=`articoli`.`id categoria` WHERE `articoli`.`id categoria` IS NULL;");
  268.         
  269.         foreach($ids as $i){
  270.             $thisDB->query("DELETE FROM `categorieWHERE `id categoria`='$i'");
  271.         }
  272.  
  273.         #$thisDB->disconnect();
  274.         return true;
  275.      }
  276.      
  277.     /**
  278.      * Ritorna gli autori memorizzati in questo Database.
  279.      * 
  280.      * Ritorna un array contenente gli autori di tutti i
  281.      * siti contenuti in questo Database.
  282.      *
  283.      * @return mixed un array contenente i siti in questo Database se
  284.      *          l'operazione è andata a buon fine, altrimenti un DB_ERROR
  285.      * @see Author
  286.      */
  287.      function getAuthors()
  288.      {
  289.          $thisDB $this->getDB();
  290.          $ids $thisDB->getCol("SELECT `id autore` FROM `autori`;");
  291.          #$thisDB->disconnect();
  292.                  
  293.          $authors array();
  294.          foreach ($ids as $i{
  295.              $authors[new Author($i$this);
  296.          }
  297.  
  298.  
  299.         return $authors;
  300.      }
  301.      
  302.     /**
  303.      * Aggiunge un autore a quelli memorizzati in questo Database
  304.      * (Factory Method).
  305.      * 
  306.      * Crea un nuovo autore e lo memorizza nel Database sottostante.
  307.      * Questo è l'unico modo per creare un nuovo autore!
  308.      *
  309.      * @param string $name il nome di battesimo dell'autore da aggiungere
  310.      * @param string $surname il congnome (da nubile) dell'autore
  311.      * @param string $nick il nome internet dell'autore o ""
  312.      * @param string $email il recapito email dell'autore
  313.      * @return mixed l'autore se l'operazione è andata a buon fine, altrimenti
  314.      *          un DB_ERROR
  315.      * @see Author
  316.      */
  317.      function addAuthor($name$surname$nick$email)
  318.      {
  319.         $thisDB $this->getDB();
  320.         $authorID $thisDB->escapeSimple($thisDB->nextID("id autore"));
  321.         $name $thisDB->escapeSimple($name);
  322.         $surname $thisDB->escapeSimple($surname);
  323.         $nick $thisDB->escapeSimple($nick);
  324.         $email $thisDB->escapeSimple($email);
  325.         $sql "INSERT INTO `autori` ( `id autore` , `nome autore` , `cognome autore` ,".
  326.                "`nick autore` , `email autore` ) ".
  327.                "VALUES ( '$authorID', '$name', '$surname', '$nick', '$email' );";
  328.                
  329.         $thisDB->query($sql);
  330.  
  331.         #$thisDB->disconnect();
  332.         return new Author($authorID$this);
  333.      }
  334.  
  335.     /**
  336.      * Cancella un autore tra quelli memorizzati in questo Database.
  337.      * 
  338.      * Cancella un autore memorizzato  nel Database sottostante, incluse tutti i
  339.      * dati personali. Questa operazione è possibile SOLO se non esistono pagine
  340.      * o siti creati da questo autore.
  341.      *
  342.      * @param Author $author l'autore da cancellare
  343.      * @return mixed true se l'operazione è andata a buon fine, false se l'autore
  344.      *  ha pagine, articoli o siti, altrimenti un DB_ERROR;
  345.      * @see Author
  346.      */
  347.      function dropAuthor($author)
  348.      {
  349.         $thisDB $this->getDB();
  350.         $authorID $thisDB->escapeSimple($author->getID());
  351.         
  352.         $sql "SELECT COUNT(`id pagina`) FROM `pagine`".
  353.                "WHERE `id autore` = '$authorID'";
  354.         $result $thisDB->getOne($sql);
  355.  
  356.         //Se l'autore ha pagine sue...
  357.         if ($result>0){
  358.             #$thisDB->disconnect();
  359.             return false;
  360.         else {
  361.             //...altrimenti si può cancellare
  362.             $sql "DELETE FROM `autoriWHERE `id autore` = '$authorID'";
  363.             $thisDB->query($sql);
  364.             #$thisDB->disconnect();
  365.             return true;
  366.         }
  367.      }
  368.      
  369.     /**
  370.      * Determina se è possibile cancellare un autore o meno.
  371.      *
  372.      * Determina se è possibile cancellare un autore o meno (un autore
  373.      * è cancellabile se non ha pagine o siti propri).
  374.      *
  375.      * @param Author $author l'autore da cancellare
  376.      * @return true se è possibile, false se l'autore
  377.      *  ha pagine, articoli o siti
  378.      * @see Author
  379.      */
  380.      function isAuthorDroppable($author){
  381.         $thisDB $this->getDB();
  382.         $authorID $thisDB->escapeSimple($author->getID());
  383.         
  384.         $sql "SELECT COUNT(`id pagina`) FROM `pagine`".
  385.                "WHERE `id autore` = '$authorID'";
  386.         $result $thisDB->getOne($sql);
  387.  
  388.         #$thisDB->disconnect();
  389.         if ($result>0){
  390.             return false;
  391.         }
  392.         else {
  393.             return true;
  394.         }
  395.      }
  396.      
  397.     /**
  398.      * Ritorna tutti i componenti utilizzabili (non necessariamente già in
  399.      * uso) dai siti gestiti con MCMS.
  400.      * 
  401.      * Ritorna un array contenente tutti i componenti opzionali per i siti
  402.      * (ossia le classi nei file della cartella Components).
  403.      *
  404.      * @return array un array contenente i componenti in questa implementazione
  405.      *  di MCMS.
  406.      * @see Component
  407.      */
  408.      function getComponents()
  409.      {
  410.          $result array();
  411.          if ($dir @opendir($_SERVER["DOCUMENT_ROOT"]."/admin/lib/plugins/")) {
  412.              $file readdir($dir);
  413.              while ($file != false{
  414.                  if (substr($file,-4== ".php"){
  415.                      $className substr_replace($file""-4);
  416.                      require_once $_SERVER["DOCUMENT_ROOT"]."/admin/lib/plugins/".$file;
  417.                      //Costruisco il componente
  418.                      $c new $className();
  419.                      $result[new $className();
  420.                  }
  421.                  $file readdir($dir);
  422.              }
  423.              closedir($dir);
  424.          }
  425.  
  426.          return $result;
  427.      }
  428.  
  429.     /**
  430.      * Crea le tabelle per MCMS.
  431.      *
  432.      * Crea le tabelle (vuote) necessarie per il funzionamento di MCMS. Necessita dei
  433.      * privilegi necesssari alla creazione delle tabelle.
  434.      *
  435.      * @access private
  436.      * @return mixed true se l'operazione è andata a buon fine, altrimenti
  437.      *          un DB_ERROR
  438.      * @see PEAR::DB
  439.      */
  440.      function createTables()
  441.      {
  442.         $sql array(
  443.                  "CREATE TABLE `siti` (
  444.                   `id sito` int(11) NOT NULL default '0',
  445.                   `url sito` text NOT NULL,
  446.                   PRIMARY KEY  (`id sito`),
  447.                   INDEX `indice siti` (`id sito`)
  448.                 );",
  449.                 "CREATE TABLE `autori` (
  450.                   `id autore` int(11) NOT NULL default '0',
  451.                   `nome autore` char(255) NOT NULL default '',
  452.                   `cognome autore` char(255) NOT NULL default '',
  453.                   `nick autore` char(255) default NULL,
  454.                   `email autore` char(255) default NULL,
  455.                   PRIMARY KEY  (`id autore`),
  456.                   INDEX `indice autori` (`id autore`)
  457.                 );",
  458.                 "CREATE TABLE `pagine` (
  459.                   `id pagina` int(11) NOT NULL default '0',
  460.                   `id sito` int(11) NOT NULL default '0',
  461.                   `id autore` int(11) NOT NULL default '0',
  462.                   `contenuto pagina` text NOT NULL,
  463.                   `data pagina` date NOT NULL default '0000-00-00',
  464.                   `titolo pagina` varchar(100) NOT NULL default 'Senza titolo',
  465.                   `parole chiave pagina` text NOT NULL,
  466.                   PRIMARY KEY  (`id pagina`),
  467.                   FOREIGN KEY (`id sito`) REFERENCES `siti` (`id sito`),
  468.                   FOREIGN KEY (`id autore`) REFERENCES `autori` (`id autore`),
  469.                   INDEX `indice pagine 1` (`id pagina`),
  470.                   INDEX `indice pagine 2` (`id sito`),
  471.                   INDEX `indice pagine 3` (`data pagina`)
  472.                 );",
  473.                 "CREATE TABLE `notizie` (
  474.                   `id pagina` int(11) NOT NULL default '0',
  475.                   `url fonte notizia` text,
  476.                   PRIMARY KEY  (`id pagina`),
  477.                   FOREIGN KEY (`id pagina`) REFERENCES `pagine` (`id pagina`),
  478.                   INDEX `indice notizie` (`id pagina`)
  479.                 );",
  480.                 "CREATE TABLE `homepages` (
  481.                   `id pagina` int(11) NOT NULL default '0',
  482.                   `motto homepage` char(255) NOT NULL default '',
  483.                   PRIMARY KEY  (`id pagina`),
  484.                   FOREIGN KEY (`id pagina`) REFERENCES `pagine` (`id pagina`),
  485.                   INDEX `indice homepages` (`id pagina`)
  486.                 );",
  487.                 "CREATE TABLE `categorie` (
  488.                   `id categoria` int(11) NOT NULL default '0',
  489.                   `nome categoria` char(255) NOT NULL default '',
  490.                   `descrizione categoria` text NOT NULL,
  491.                   `id sito` int(11) NOT NULL default '0',
  492.                   PRIMARY KEY  (`id categoria`),
  493.                   INDEX `indice categorie 1` (`id categoria`),
  494.                   INDEX `indice categorie 2` (`id sito`)
  495.                 );",
  496.                 "CREATE TABLE `articoli` (
  497.                   `id pagina` int(11) NOT NULL default '0',
  498.                   `id categoria` int(11) NOT NULL default '0',
  499.                   `descrizione articolo` text NOT NULL,
  500.                   PRIMARY KEY  (`id pagina`),
  501.                   FOREIGN KEY (`id pagina`) REFERENCES `pagine` (`id pagina`),
  502.                   FOREIGN KEY (`id categoria`) REFERENCES `categoria` (`id categoria`),
  503.                   INDEX `indice articoli 1` (`id pagina`),
  504.                   INDEX `indice articoli 2` (`id categoria`)
  505.                 );",
  506.                 /*"CREATE TABLE `componenti` (
  507.                   `id componente` int(11) NOT NULL default '0',
  508.                   `nome componente` char(255) NOT NULL default '',
  509.                   `descrizione componente` text NOT NULL,
  510.                   PRIMARY KEY  (`id componente`)
  511.                 );",*/
  512.                 "CREATE TABLE `articoli correlati articolo` (
  513.                   `id articolo` int(11) NOT NULL default '0',
  514.                   `id articolo correlato` int(11) NOT NULL default '0',
  515.                   PRIMARY KEY  (`id articolo`,`id articolo correlato`),
  516.                   FOREIGN KEY (`id articolo`) REFERENCES `articoli` (`id pagina`),
  517.                   FOREIGN KEY (`id articolo correlato`) REFERENCES `articoli` (`id pagina`),
  518.                   INDEX `indice articoli correlati articolo 1` (`id articolo`),
  519.                   INDEX `indice articoli correlati articolo 2` (`id articolo correlato`)
  520.                 );",
  521.                 "CREATE TABLE `articoli correlati notizia` (
  522.                   `id notizia` int(11) NOT NULL default '0',
  523.                   `id articolo` int(11) NOT NULL default '0',
  524.                   PRIMARY KEY  (`id notizia`,`id articolo`),
  525.                   FOREIGN KEY (`id notizia`) REFERENCES `notizie` (`id pagina`),
  526.                   FOREIGN KEY (`id articolo`) REFERENCES `siti` (`id pagina`),
  527.                   INDEX `indice articoli correlati notizia 1` (`id notizia`),
  528.                   INDEX `indice articoli correlati notizia 2` (`id articolo`)
  529.                 );",
  530.                 "CREATE TABLE `componenti siti` (
  531.                   `id sito` int(11) NOT NULL default '0',
  532.                   `nome componente` char(255) NOT NULL default '',
  533.                   PRIMARY KEY  (`id sito`,`nome componente`),
  534.                   FOREIGN KEY (`id sito`) REFERENCES `siti` (`id sito`),
  535.                   INDEX `indice componenti siti` (`id sito`)
  536.                 );",
  537.                 //Tabella per l'autenticazione degli utenti
  538.                "CREATE TABLE auth (
  539.                    username VARCHAR(50) default '' NOT NULL,
  540.                    password VARCHAR(32) default '' NOT NULL,
  541.                    PRIMARY KEY (username),
  542.                    KEY (password)
  543.                 );");
  544.         $thisDB $this->getDB();
  545.         foreach ($sql as $i{
  546.             $thisDB->query($i);
  547.         }
  548.         $thisDB->createSequence("id sito");
  549.         $thisDB->createSequence("id autore");
  550.         $thisDB->createSequence("id pagina");
  551.         $thisDB->createSequence("id componente");
  552.         $thisDB->createSequence("id categoria");
  553.         
  554.         #$thisDB->disconnect();
  555.      }
  556. }
  557. ?>

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