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

Source for file Page.php

Documentation is available at Page.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 delle pagine del sito.
  27.  *
  28.  * @package  MCMS
  29.  * @version  2
  30.  * @author   Silvio Moioli <silvio at moioli dot net>
  31.  *
  32.  */
  33.  
  34. /** Carica la classe base di MCMS per l'interfacciamento al Database */
  35. require_once $_SERVER["DOCUMENT_ROOT"]."/admin/lib/model/Engine.php";
  36. /**
  37.  * Carica la classe per gli articoli (Article)
  38.  */
  39. require_once $_SERVER["DOCUMENT_ROOT"]."/admin/lib/model/Site.php";
  40. /**
  41.  * Carica la classe per gli autori (Author)
  42.  */
  43. require_once $_SERVER["DOCUMENT_ROOT"]."/admin/lib/model/Author.php";
  44.  
  45. /**
  46.  * Interfaccia per la gestione delle pagine del sito.
  47.  *
  48.  * Permette di utilizzare il database in modo trasparente: creare oggetti
  49.  * di questa classe e operare sugli attributi tramite gli appositi metodi
  50.  * modificherà automaticamente il database sottostante.
  51.  * 
  52.  * @abstract
  53.  * @package  MCMS
  54.  * @version  2
  55.  * @author   Silvio Moioli <silvio at moioli dot net>
  56.  *
  57.  */
  58. /* abstract */ class Page extends PEAR
  59. {
  60.     //Attributi
  61.         /**
  62.      * @var int $ID ID del database sottostante per questa pagina.
  63.      */
  64.     var $ID = 0;
  65.     /**
  66.      * @var Engine il motore del database sottostante per questa pagina.
  67.      */
  68.     var $engine = null;
  69.  
  70.     //Costruttori   
  71.         /**
  72.      * Costruttore di lettura
  73.      *
  74.      * Costruttore "di lettura" (costruisce una pagina da un record del
  75.      * database già esistente).
  76.      * Nota: non può essere creata una nuova pagina da qui, ma solo dal Factory
  77.      * Method nella classe Site.
  78.      * Per i costruttori "di scrittura", quindi, vedere la classe Site
  79.      * nel file Site.php.
  80.      *
  81.      * @param int $ID l'ID del database sottostante
  82.      * @param Engine $engine un motore per interagire con il database
  83.      *  sottostante
  84.      * @return mixed la pagina se la costruzione è andata a buon fine, altrimenti
  85.      *  un PEAR_Error
  86.      * @see Engine
  87.      */
  88.     function Page($ID$engine)
  89.     {
  90.         if (settype($ID"integer"&& $ID>0){
  91.              $this->ID = $ID;
  92.         }
  93.         else {
  94.              $this->raiseError("Page: invalid ID: ".$ID);
  95.         }
  96.         if ($engine != null){
  97.              $this->engine = $engine;
  98.         }
  99.         else {
  100.              $this->raiseError("Page: null engine");
  101.         }
  102.     }
  103.     
  104.     //Metodi
  105.         /**
  106.      * Ritorna l'ID di questa pagina.
  107.      * 
  108.      * Solo le classi che ereditano da questa potrebbero avere bisogno di
  109.      * questo parametro, per le interrogazioni al Database.
  110.      *
  111.      * @access protected
  112.      * @return int l'ID del database sottostante
  113.      */
  114.      function getID()
  115.      {
  116.        return $this->ID;
  117.      }
  118.  
  119.     /**
  120.      * Ritorna il motore di questa pagina.
  121.      * 
  122.      * Solo le classi di MCMS potrebbero avere bisogno di
  123.      * questo parametro, per le interrogazioni al Database.
  124.      *
  125.      * @access private
  126.      * @return Engine il motore del database sottostante
  127.      */
  128.      function getEngine()
  129.      {
  130.        return $this->engine;
  131.      }
  132.  
  133.     /**
  134.      * Getter per il campo Sito dalla tabella Pagina.
  135.      * 
  136.      * Ritorna un oggetto corrispondente al sito di appartenenza di questa
  137.      * pagina. Permette di utilizzare il database in modo trasparente (è come
  138.      * se si usassero normali attributi di una classe).
  139.      *
  140.      * @return Site il sito a cui questa pagina appartiene.
  141.      * @see Site
  142.      */
  143.      function getSite()
  144.      {
  145.         $thisEngine $this->getEngine();
  146.         $thisDB $thisEngine->getDB();
  147.         $thisID $thisDB->escapeSimple($this->getID());
  148.         $hpID $thisDB->getOne("SELECT `id sito` FROM `pagine`".
  149.                                 "WHERE `id pagina` = '$thisIDLIMIT 1;");
  150.         
  151.         #$thisDB->disconnect();
  152.         return new Site($hpID$thisEngine);
  153.      }
  154.      
  155.     /**
  156.      * Setter per il campo Sito dalla tabella Pagina.
  157.      * 
  158.      * Cambia l'oggetto corrispondente al sito di appartenenza di questa
  159.      * pagina. Permette di utilizzare il database in modo trasparente (è come
  160.      * se si usassero normali attributi di una classe).
  161.      *
  162.      * @param Site $site il sito a cui questa pagina appartiene.
  163.      * @return mixed true se la connessione è andata a buon fine, altrimenti
  164.      *  un DB_ERROR
  165.      * @see Site
  166.      */
  167.      function setSite($site)
  168.      {
  169.         $thisEngine $this->getEngine();
  170.         $thisDB $thisEngine->getDB();
  171.         $thisID $thisDB->escapeSimple($this->getID());
  172.         $newSiteID $thisDB->escapeSimple($site->getID());
  173.         $thisDB->query("UPDATE `pagineSET `id categoria`='$newSiteID'".
  174.                        "WHERE `id pagina` = '$thisID';");
  175.         
  176.         #$thisDB->disconnect();
  177.         return true;
  178.      }
  179.      
  180.     /**
  181.      * Getter per il campo Autore dalla tabella Pagina.
  182.      * 
  183.      * Ritorna un oggetto corrispondente all'autore principale di questa pagina
  184.      * Permette di utilizzare il database in modo trasparente (è come se si
  185.      * usassero normali attributi di una classe).
  186.      *
  187.      * @return Author l'autore a cui questa pagina appartiene.
  188.      * @see Author
  189.      */
  190.      function getAuthor()
  191.      {
  192.         $thisEngine $this->getEngine();
  193.         $thisDB $thisEngine->getDB();
  194.         $thisID $thisDB->escapeSimple($this->getID());
  195.         $hpID $thisDB->getOne("SELECT `id autore` FROM `pagine`".
  196.                                 "WHERE `id pagina` = '$thisIDLIMIT 1;");
  197.         
  198.         #$thisDB->disconnect();
  199.         return new Author($hpID$thisEngine);
  200.      }
  201.     
  202.     /**
  203.      * Setter per il campo Autore dalla tabella Pagina.
  204.      * 
  205.      * Cambia l'oggetto corrispondente all'autore principale di questa pagina
  206.      * Permette di utilizzare il database in modo trasparente (è come se si
  207.      * usassero normali attributi di una classe).
  208.      *
  209.      * @param Author $author l'autore a cui questa pagina appartiene.
  210.      * @return mixed true se la connessione è andata a buon fine, altrimenti
  211.      *  un DB_ERROR
  212.      * @see Author
  213.      */
  214.      function setAuthor($author)
  215.      {
  216.         $thisEngine $this->getEngine();
  217.         $thisDB $thisEngine->getDB();
  218.         $thisID $thisDB->escapeSimple($this->getID());
  219.         $newAuthorID $thisDB->escapeSimple($author->getID());
  220.         $thisDB->query("UPDATE `pagineSET `id autore`='$newAuthorID'".
  221.                        "WHERE `id pagina` = '$thisID';");
  222.         
  223.         #$thisDB->disconnect();
  224.         return true;
  225.      }
  226.     
  227.     /**
  228.      * Getter per il campo Contenuto dalla tabella Pagina.
  229.      * 
  230.      * Ritorna una stringa corrispondente al contenuto (HTML) della pagina
  231.      * Permette di utilizzare il database in modo trasparente (è come se si
  232.      * usassero normali attributi di una classe).
  233.      *
  234.      * @return string il contenuto HTML di questa pagina appartiene.
  235.      */
  236.      function getContents()
  237.      {
  238.         $thisEngine $this->getEngine();
  239.         $thisDB $thisEngine->getDB();
  240.         $thisID $thisDB->escapeSimple($this->getID());
  241.         $res $thisDB->getOne("SELECT `contenuto pagina` FROM `pagine`".
  242.                                 "WHERE `id pagina` = '$thisIDLIMIT 1;");
  243.         
  244.         #$thisDB->disconnect();
  245.         return $res;
  246.      }
  247.     
  248.     /**
  249.      * Setter per il campo Contenuto dalla tabella Pagina.
  250.      * 
  251.      * Cambia la stringa corrispondente al contenuto (HTML) della pagina
  252.      * Permette di utilizzare il database in modo trasparente (è come se si
  253.      * usassero normali attributi di una classe).
  254.      *
  255.      * @param string $contents il contenuto HTML di questa pagina.
  256.      * @return mixed true se la connessione è andata a buon fine, altrimenti
  257.      *  un DB_ERROR
  258.      */
  259.      function setContents($contents)
  260.      {
  261.         $thisEngine $this->getEngine();
  262.         $thisDB $thisEngine->getDB();
  263.         $thisID $thisDB->escapeSimple($this->getID());
  264.         $contents $thisDB->escapeSimple($contents);
  265.         $thisDB->query("UPDATE `pagineSET `contenuto pagina`='$contents'".
  266.                        "WHERE `id pagina` = '$thisID';");
  267.         
  268.         #$thisDB->disconnect();
  269.         return true;
  270.      }
  271.  
  272.     /**
  273.      * Getter per il campo Data dalla tabella Pagina.
  274.      *
  275.      * Ritorna un oggetto corrispondente alla data di ultima modifica di
  276.      * questa pagina. Permette di utilizzare il database in modo
  277.      * trasparente (è come se si usassero normali attributi di una classe).
  278.      *
  279.      * @return PEAR::Date l'ora dell'ultima modifica di questa pagina.
  280.      * @see PEAR::Date
  281.      */
  282.      function getDate()
  283.      {
  284.         $thisEngine $this->getEngine();
  285.         $thisDB $thisEngine->getDB();
  286.         $thisID $thisDB->escapeSimple($this->getID());
  287.         $res $thisDB->getOne("SELECT `data pagina` FROM `pagine`".
  288.                                 "WHERE `id pagina` = '$thisIDLIMIT 1;");
  289.  
  290.         #$thisDB->disconnect();
  291.         return $res;
  292.      }
  293.     
  294.     /**
  295.      * Setter per il campo Data dalla tabella Pagina.
  296.      * 
  297.      * Cambia l'oggetto corrispondente alla data di ultima modifica di
  298.      * questa pagina. Permette di utilizzare il database in modo
  299.      * trasparente (è come se si usassero normali attributi di una classe).
  300.      *
  301.      * @param PEAR::Date $date l'ora dell'ultima modifica di questa pagina.
  302.      * @return mixed true se l'operazione è andata a buon fine, altrimenti
  303.      *  un DB_ERROR
  304.      * @see PEAR::Date
  305.      */
  306.      function setDate($date)
  307.      {
  308.         $thisEngine $this->getEngine();
  309.         $thisDB $thisEngine->getDB();
  310.         $thisID $thisDB->escapeSimple($this->getID());
  311.         $escapedDate $thisDB->escapeSimple($date);
  312.         $thisDB->query("UPDATE `pagineSET `data pagina`='$escapedDate'".
  313.                        "WHERE `id pagina` = '$thisID';");
  314.         
  315.         #$thisDB->disconnect();
  316.         return true;
  317.      }
  318.      
  319.     /**
  320.      * Getter per il campo Titolo dalla tabella Pagina.
  321.      * 
  322.      * Ritorna una stringa corrispondente al titolo di questa pagina
  323.      * Permette di utilizzare il database in modo trasparente (è come se si
  324.      * usassero normali attributi di una classe).
  325.      *
  326.      * @return string il titolo di questa pagina.
  327.      */
  328.      function getTitle()
  329.      {
  330.         $thisEngine $this->getEngine();
  331.         $thisDB $thisEngine->getDB();
  332.         $thisID $thisDB->escapeSimple($this->getID());
  333.         $res $thisDB->getOne("SELECT `titolo pagina` FROM `pagine`".
  334.                                 "WHERE `id pagina` = '$thisIDLIMIT 1;");
  335.         
  336.         #$thisDB->disconnect();
  337.         return $res;
  338.      }
  339.      
  340.     /**
  341.      * Setter per il campo Titolo dalla tabella Pagina.
  342.      * 
  343.      * Cambia la stringa corrispondente al titolo di questa pagina
  344.      * Permette di utilizzare il database in modo trasparente (è come se si
  345.      * usassero normali attributi di una classe).
  346.      *
  347.      * @param string $title il titolo di questa pagina.
  348.      * @return mixed true se la connessione è andata a buon fine, altrimenti
  349.      *  un DB_ERROR
  350.      */
  351.      function setTitle($title)
  352.      {
  353.         $thisEngine $this->getEngine();
  354.         $thisDB $thisEngine->getDB();
  355.         $thisID $thisDB->escapeSimple($this->getID());
  356.         $title $thisDB->escapeSimple($thisDB->escapeSimple($title));
  357.         $thisDB->query("UPDATE `pagineSET `titolo pagina`='$title'".
  358.                        "WHERE `id pagina` = '$thisID';");
  359.         
  360.         #$thisDB->disconnect();
  361.         return true;
  362.      }
  363.  
  364.     /**
  365.      * Getter per il campo ParoleChiave dalla tabella Pagina.
  366.      * 
  367.      * Ritorna una stringa con tutte le parole chiave di questa pagina.
  368.      * L'elenco deve separato da virgole e spazi (per esempio "case, amici").
  369.      * Permette di utilizzare il database in modo trasparente (è come se si
  370.      * usassero normali attributi di una classe).
  371.      *
  372.      * @return string l'elenco separato da virgole e spazi
  373.      *  (per esempio "case, amici") delle parole chiave della pagina.
  374.      */
  375.      function getKeywords()
  376.      {
  377.         $thisEngine $this->getEngine();
  378.         $thisDB $thisEngine->getDB();
  379.         $thisID $thisDB->escapeSimple($this->getID());
  380.         $res $thisDB->getOne("SELECT `parole chiave pagina` FROM `pagine`".
  381.                                "WHERE `id pagina` = '$thisIDLIMIT 1;");
  382.         
  383.         #$thisDB->disconnect();
  384.         return $res;
  385.      }
  386.      
  387.     /**
  388.      * Setter per il campo ParoleChiave dalla tabella Pagina.
  389.      * 
  390.      * Cambia la stringa con tutte le parole chiave di questa pagina.
  391.      * L'elenco deve separato da virgole e spazi (per esempio "case, amici").
  392.      * Permette di utilizzare il database in modo trasparente (è come se si
  393.      * usassero normali attributi di una classe).
  394.      *
  395.      * @param string $keywords l'elenco separato da virgole e spazi
  396.      *  (per esempio "case, amici") delle parole chiave della pagina.
  397.      * @return mixed true se la connessione è andata a buon fine, altrimenti
  398.      *  un DB_ERROR
  399.      */
  400.      function setKeywords($keywords)
  401.      {
  402.         $thisEngine $this->getEngine();
  403.         $thisDB $thisEngine->getDB();
  404.         $thisID $thisDB->escapeSimple($this->getID());
  405.         $keywords $thisDB->escapeSimple($keywords);
  406.         $thisDB->query("UPDATE `pagineSET `parole chiave pagina`='$keywords'".
  407.                        "WHERE `id pagina` = '$thisID';");
  408.         
  409.         #$thisDB->disconnect();
  410.         return true;
  411.      }
  412. }
  413. ?>

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