Source for file abook_database.php

Documentation is available at abook_database.php

  1. <?php
  2.  
  3. /**
  4.  * abook_database.php
  5.  *
  6.  * @copyright &copy; 1999-2006 The SquirrelMail Project Team
  7.  * @license http://opensource.org/licenses/gpl-license.php GNU Public License
  8.  * @version $Id: abook_database.php,v 1.15.2.17 2006/10/07 11:58:42 tokul Exp $
  9.  * @package squirrelmail
  10.  * @subpackage addressbook
  11.  */
  12.  
  13. /** Needs the DB functions */
  14. if (!include_once('DB.php')) {
  15.     // same error also in db_prefs.php
  16.         require_once(SM_PATH . 'functions/display_messages.php');
  17.     $error  = _("Could not include PEAR database functions required for the database backend.") . "<br />\n";
  18.     $error .= sprintf(_("Is PEAR installed, and is the include path set correctly to find %s?"),
  19.                         '<tt>DB.php</tt>') . "<br />\n";
  20.     $error .= _("Please contact your system administrator and report this error.");
  21.     error_box($error, $color);
  22.     exit;
  23. }
  24.  
  25. /**
  26.  * Address book in a database backend
  27.  *
  28.  * Backend for personal/shared address book stored in a database,
  29.  * accessed using the DB-classes in PEAR.
  30.  *
  31.  * IMPORTANT:  The PEAR modules must be in the include path
  32.  * for this class to work.
  33.  *
  34.  * An array with the following elements must be passed to
  35.  * the class constructor (elements marked ? are optional):
  36.  * <pre>
  37.  *   dsn       => database DNS (see PEAR for syntax)
  38.  *   table     => table to store addresses in (must exist)
  39.  *   owner     => current user (owner of address data)
  40.  * ? name      => name of address book
  41.  * ? writeable => set writeable flag (true/false)
  42.  * ? listing   => enable/disable listing
  43.  * </pre>
  44.  * The table used should have the following columns:
  45.  * owner, nickname, firstname, lastname, email, label
  46.  * The pair (owner,nickname) should be unique (primary key).
  47.  *
  48.  *  NOTE. This class should not be used directly. Use the
  49.  *        "AddressBook" class instead.
  50.  * @package squirrelmail
  51.  * @subpackage addressbook
  52.  */
  53. class abook_database extends addressbook_backend {
  54.     /**
  55.      * Backend type
  56.      * @var string 
  57.      */
  58.     var $btype = 'local';
  59.     /**
  60.      * Backend name
  61.      * @var string 
  62.      */
  63.     var $bname = 'database';
  64.  
  65.     /**
  66.      * Data Source Name (connection description)
  67.      * @var string 
  68.      */
  69.     var $dsn       = '';
  70.     /**
  71.      * Table that stores addresses
  72.      * @var string 
  73.      */
  74.     var $table     = '';
  75.     /**
  76.      * Owner name
  77.      *
  78.      * Limits list of database entries visible to end user
  79.      * @var string 
  80.      */
  81.     var $owner     = '';
  82.     /**
  83.      * Database Handle
  84.      * @var resource 
  85.      */
  86.     var $dbh       = false;
  87.     /**
  88.      * Enable/disable writing into address book
  89.      * @var bool 
  90.      */
  91.     var $writeable = true;
  92.     /**
  93.      * Enable/disable address book listing
  94.      * @var bool 
  95.      */
  96.     var $listing = true;
  97.  
  98.     /* ========================== Private ======================= */
  99.  
  100.     /**
  101.      * Constructor
  102.      * @param array $param address book backend options
  103.      */
  104.     function abook_database($param) {
  105.         $this->sname = _("Personal address book");
  106.  
  107.         if (is_array($param)) {
  108.             if (empty($param['dsn']) ||
  109.                 empty($param['table']) ||
  110.                 empty($param['owner'])) {
  111.                 return $this->set_error('Invalid parameters');
  112.             }
  113.  
  114.             $this->dsn   = $param['dsn'];
  115.             $this->table = $param['table'];
  116.             $this->owner = $param['owner'];
  117.  
  118.             if (!empty($param['name'])) {
  119.                $this->sname = $param['name'];
  120.             }
  121.  
  122.             if (isset($param['writeable'])) {
  123.                $this->writeable = $param['writeable'];
  124.             }
  125.  
  126.             if (isset($param['listing'])) {
  127.                $this->listing = $param['listing'];
  128.             }
  129.  
  130.             $this->open(true);
  131.         }
  132.         else {
  133.             return $this->set_error('Invalid argument to constructor');
  134.         }
  135.     }
  136.  
  137.  
  138.     /**
  139.      * Open the database.
  140.      * @param bool $new new connection if it is true
  141.      * @return bool 
  142.      */
  143.     function open($new = false) {
  144.         $this->error = '';
  145.  
  146.         /* Return true is file is open and $new is unset */
  147.         if ($this->dbh && !$new) {
  148.             return true;
  149.         }
  150.  
  151.         /* Close old file, if any */
  152.         if ($this->dbh) {
  153.             $this->close();
  154.         }
  155.  
  156.         $dbh = DB::connect($this->dsn, true);
  157.  
  158.         if (DB::isError($dbh)) {
  159.             return $this->set_error(sprintf(_("Database error: %s"),
  160.                                             DB::errorMessage($dbh)));
  161.         }
  162.  
  163.         $this->dbh = $dbh;
  164.  
  165.         /**
  166.          * field names are lowercased.
  167.          * We use unquoted identifiers and they use upper case in Oracle
  168.          */
  169.         $this->dbh->setOption('portability', DB_PORTABILITY_LOWERCASE);
  170.  
  171.         return true;
  172.     }
  173.  
  174.     /**
  175.      * Close the file and forget the filehandle
  176.      */
  177.     function close() {
  178.         $this->dbh->disconnect();
  179.         $this->dbh = false;
  180.     }
  181.  
  182.     /* ========================== Public ======================== */
  183.  
  184.     /**
  185.      * Search the database
  186.      * @param string $expr search expression
  187.      * @return array search results
  188.      */
  189.     function search($expr) {
  190.         $ret = array();
  191.         if(!$this->open()) {
  192.             return false;
  193.         }
  194.  
  195.         /* To be replaced by advanded search expression parsing */
  196.         if (is_array($expr)) {
  197.             return;
  198.         }
  199.  
  200.         // don't allow wide search when listing is disabled.
  201.         if ($expr=='*' && ! $this->listing) {
  202.             return array();
  203.         }
  204.  
  205.         /* lowercase expression in order to make it case insensitive */
  206.         $expr = strtolower($expr);
  207.  
  208.         /* escape SQL wildcards */
  209.         $expr = str_replace('_', '\\_', $expr);
  210.         $expr = str_replace('%', '\\%', $expr);
  211.  
  212.         /* Convert wildcards to SQL syntax  */
  213.         $expr = str_replace('?', '_', $expr);
  214.         $expr = str_replace('*', '%', $expr);
  215.         $expr = $this->dbh->quoteString($expr);
  216.         $expr = "%$expr%";
  217.  
  218.         /* create escape expression */
  219.         $escape = 'ESCAPE \'' . $this->dbh->quoteString('\\') . '\'';
  220.  
  221.         $query = sprintf("SELECT * FROM %s WHERE owner='%s' AND " .
  222.                          "(LOWER(firstname) LIKE '%s' %s OR LOWER(lastname) LIKE '%s' %s)",
  223.                          $this->table, $this->owner, $expr, $escape, $expr, $escape);
  224.         $res = $this->dbh->query($query);
  225.  
  226.         if (DB::isError($res)) {
  227.             return $this->set_error(sprintf(_("Database error: %s"),
  228.                                             DB::errorMessage($res)));
  229.         }
  230.  
  231.         while ($row = $res->fetchRow(DB_FETCHMODE_ASSOC)) {
  232.             array_push($ret, array('nickname'  => $row['nickname'],
  233.                                    'name'      => "$row[firstname] $row[lastname]",
  234.                                    'firstname' => $row['firstname'],
  235.                                    'lastname'  => $row['lastname'],
  236.                                    'email'     => $row['email'],
  237.                                    'label'     => $row['label'],
  238.                                    'backend'   => $this->bnum,
  239.                                    'source'    => &$this->sname));
  240.         }
  241.         return $ret;
  242.     }
  243.  
  244.     /**
  245.      * Lookup alias
  246.      * @param string $alias alias
  247.      * @return array search results
  248.      */
  249.     function lookup($alias) {
  250.         if (empty($alias)) {
  251.             return array();
  252.         }
  253.  
  254.         $alias = strtolower($alias);
  255.  
  256.         if (!$this->open()) {
  257.             return false;
  258.         }
  259.  
  260.         $query = sprintf("SELECT * FROM %s WHERE owner='%s' AND LOWER(nickname)='%s'",
  261.                          $this->table, $this->owner, $this->dbh->quoteString($alias));
  262.  
  263.         $res = $this->dbh->query($query);
  264.  
  265.         if (DB::isError($res)) {
  266.             return $this->set_error(sprintf(_("Database error: %s"),
  267.                                             DB::errorMessage($res)));
  268.         }
  269.  
  270.         if ($row = $res->fetchRow(DB_FETCHMODE_ASSOC)) {
  271.             return array('nickname'  => $row['nickname'],
  272.                          'name'      => "$row[firstname] $row[lastname]",
  273.                          'firstname' => $row['firstname'],
  274.                          'lastname'  => $row['lastname'],
  275.                          'email'     => $row['email'],
  276.                          'label'     => $row['label'],
  277.                          'backend'   => $this->bnum,
  278.                          'source'    => &$this->sname);
  279.         }
  280.         return array();
  281.     }
  282.  
  283.     /**
  284.      * List all addresses
  285.      * @return array search results
  286.      */
  287.     function list_addr() {
  288.         $ret = array();
  289.         if (!$this->open()) {
  290.             return false;
  291.         }
  292.  
  293.         if(isset($this->listing) && !$this->listing) {
  294.             return array();
  295.         }
  296.  
  297.  
  298.         $query = sprintf("SELECT * FROM %s WHERE owner='%s'",
  299.                          $this->table, $this->owner);
  300.  
  301.         $res = $this->dbh->query($query);
  302.  
  303.         if (DB::isError($res)) {
  304.             return $this->set_error(sprintf(_("Database error: %s"),
  305.                                             DB::errorMessage($res)));
  306.         }
  307.  
  308.         while ($row = $res->fetchRow(DB_FETCHMODE_ASSOC)) {
  309.             array_push($ret, array('nickname'  => $row['nickname'],
  310.                                    'name'      => "$row[firstname] $row[lastname]",
  311.                                    'firstname' => $row['firstname'],
  312.                                    'lastname'  => $row['lastname'],
  313.                                    'email'     => $row['email'],
  314.                                    'label'     => $row['label'],
  315.                                    'backend'   => $this->bnum,
  316.                                    'source'    => &$this->sname));
  317.         }
  318.         return $ret;
  319.     }
  320.  
  321.     /**
  322.      * Add address
  323.      * @param array $userdata added data
  324.      * @return bool 
  325.      */
  326.     function add($userdata) {
  327.         if (!$this->writeable) {
  328.             return $this->set_error(_("Address book is read-only"));
  329.         }
  330.  
  331.         if (!$this->open()) {
  332.             return false;
  333.         }
  334.  
  335.         /* See if user exist already */
  336.         $ret = $this->lookup($userdata['nickname']);
  337.         if (!empty($ret)) {
  338.             return $this->set_error(sprintf(_("User \"%s\" already exists"), $ret['nickname']));
  339.         }
  340.  
  341.         /* Create query */
  342.         $query = sprintf("INSERT INTO %s (owner, nickname, firstname, " .
  343.                          "lastname, email, label) VALUES('%s','%s','%s'," .
  344.                          "'%s','%s','%s')",
  345.                          $this->table, $this->owner,
  346.                          $this->dbh->quoteString($userdata['nickname']),
  347.                          $this->dbh->quoteString($userdata['firstname']),
  348.                          $this->dbh->quoteString((!empty($userdata['lastname'])?$userdata['lastname']:'')),
  349.                          $this->dbh->quoteString($userdata['email']),
  350.                          $this->dbh->quoteString((!empty($userdata['label'])?$userdata['label']:'')) );
  351.  
  352.          /* Do the insert */
  353.          $r = $this->dbh->simpleQuery($query);
  354.  
  355.          /* Check for errors */
  356.          if (DB::isError($r)) {
  357.              return $this->set_error(sprintf(_("Database error: %s"),
  358.                                              DB::errorMessage($r)));
  359.          }
  360.  
  361.          return true;
  362.     }
  363.  
  364.     /**
  365.      * Delete address
  366.      * @param string $alias alias that has to be deleted
  367.      * @return bool 
  368.      */
  369.     function remove($alias) {
  370.         if (!$this->writeable) {
  371.             return $this->set_error(_("Address book is read-only"));
  372.         }
  373.  
  374.         if (!$this->open()) {
  375.             return false;
  376.         }
  377.  
  378.         /* Create query */
  379.         $query = sprintf("DELETE FROM %s WHERE owner='%s' AND (",
  380.                          $this->table, $this->owner);
  381.  
  382.         $sepstr = '';
  383.         while (list($undef, $nickname) = each($alias)) {
  384.             $query .= sprintf("%s nickname='%s' ", $sepstr,
  385.                               $this->dbh->quoteString($nickname));
  386.             $sepstr = 'OR';
  387.         }
  388.         $query .= ')';
  389.  
  390.         /* Delete entry */
  391.         $r = $this->dbh->simpleQuery($query);
  392.  
  393.         /* Check for errors */
  394.         if (DB::isError($r)) {
  395.             return $this->set_error(sprintf(_("Database error: %s"),
  396.                                             DB::errorMessage($r)));
  397.         }
  398.         return true;
  399.     }
  400.  
  401.     /**
  402.      * Modify address
  403.      * @param string $alias modified alias
  404.      * @param array $userdata new data
  405.      * @return bool 
  406.      */
  407.     function modify($alias, $userdata) {
  408.         if (!$this->writeable) {
  409.             return $this->set_error(_("Address book is read-only"));
  410.         }
  411.  
  412.         if (!$this->open()) {
  413.             return false;
  414.         }
  415.  
  416.          /* See if user exist */
  417.         $ret = $this->lookup($alias);
  418.         if (empty($ret)) {
  419.             return $this->set_error(sprintf(_("User \"%s\" does not exist"), $alias));
  420.         }
  421.  
  422.         /* make sure that new nickname is not used */
  423.         if (strtolower($alias) != strtolower($userdata['nickname'])) {
  424.             /* same check as in add() */
  425.             $ret = $this->lookup($userdata['nickname']);
  426.             if (!empty($ret)) {
  427.                 $error = sprintf(_("User '%s' already exist."), $ret['nickname']);
  428.                 return $this->set_error($error);
  429.             }
  430.         }
  431.  
  432.         /* Create query */
  433.         $query = sprintf("UPDATE %s SET nickname='%s', firstname='%s', ".
  434.                          "lastname='%s', email='%s', label='%s' ".
  435.                          "WHERE owner='%s' AND nickname='%s'",
  436.                          $this->table,
  437.                          $this->dbh->quoteString($userdata['nickname']),
  438.                          $this->dbh->quoteString($userdata['firstname']),
  439.                          $this->dbh->quoteString((!empty($userdata['lastname'])?$userdata['lastname']:'')),
  440.                          $this->dbh->quoteString($userdata['email']),
  441.                          $this->dbh->quoteString((!empty($userdata['label'])?$userdata['label']:'')),
  442.                          $this->owner,
  443.                          $this->dbh->quoteString($alias) );
  444.  
  445.         /* Do the insert */
  446.         $r = $this->dbh->simpleQuery($query);
  447.  
  448.         /* Check for errors */
  449.         if (DB::isError($r)) {
  450.             return $this->set_error(sprintf(_("Database error: %s"),
  451.                                             DB::errorMessage($r)));
  452.         }
  453.         return true;
  454.     }
  455. } /* End of class abook_database */
  456.  
  457. // vim: et ts=4

Documentation generated on Sat, 07 Oct 2006 16:29:33 +0300 by phpDocumentor 1.3.0RC6