project/modules/openid/Module.php

   1 <?php
   2
   3 /**
   4  * Pivip
   5  * Copyright (C) 2008  Vincent Tunru
   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; version 2
  10
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  19  *
  20  * @license   http://www.fsf.org/licensing/licenses/info/GPLv2.html GPL v.2
  21  * @category  PivipModulesDefault
  22  * @package   Module_Openid
  23  * @copyright (C) 2008 Vincent Tunru
  24  * @author    Vincent Tunru <email@vincentt.org>
  25  */
  26
  27 /**
  28  * Manage the Openid module
  29  *
  30  * The Openid module allows for authentication using OpenID.
  31  *
  32  * @see /library/Pivip/Module/Abstract.php
  33  * @link http://openid.net/ OpenID.net
  34  */
  35 class Openid_Module extends Pivip_Module_Abstract
  36 {
  37         /**
  38          * @var Vogel_Config_Ini The OpenID configuration
  39          */
  40         protected static $_config;
  41
  42         /**
  43          * Load the OpenID configuration
  44          */
  45         protected static function _loadConfig()
  46         {
  47                 if(empty(self::$_config))
  48                 {
  49                         self::$_config = new Vogel_Config_Ini('./modules/openid/config.ini');
  50                 }
  51                 return self::$_config;
  52         }
  53
  54         /**
  55          * Defines the dependencies
  56          *
  57          * Openid depends on Pivip and the Page module
  58          */
  59         public function __construct()
  60         {
  61         }
  62
  63         /**
  64          * Checks whether the OpenID database table exists
  65          *
  66          * Will check whether a superuser is defined and whether the database tables
  67          * exist.
  68          *
  69          * @return boolean Whether Openid is already installed.
  70          */
  71         public static function isInstalled()
  72         {
  73                 if(!file_exists(CODE_PATH
  74                                 . 'application/models/generated/BaseOpenid.php'))
  75                 {
  76                         return false;
  77                 }
  78                 $config = self::_loadConfig();
  79                 if(empty($config->administration->superuser))
  80                 {
  81                         return false;
  82                 }
  83                 return true;
  84         }
  85
  86         /**
  87          * Check whether the authentication form has been added to the pages
  88          *
  89          * @return boolean Whether the form has been added.
  90          */
  91         public static function blockAdded()
  92         {
  93                 if(!file_exists(CODE_PATH . 'application/models/generated/BaseBlock.php'))
  94                 {
  95                         return false;
  96                 }
  97                 $cache = Page_Module::loadCache();
  98                 if(!$rows = $cache->load('core'))
  99                 {
 100                         try
 101                         {
 102                                 $query = new Doctrine_Query();
 103                                 $query->from('Block b')
 104                                       ->where('b.location=?', 'core')
 105                                       ->orderby('b.priority ASC');
 106                                 $rows = $query->execute();
 107                         } catch(Exception $e) {
 108                                 return false;
 109                         }
 110                 }
 111                 foreach($rows as $row)
 112                 {
 113                         if('openid' == $row->module &&
 114                            'authentication' == $row->controller &&
 115                            'menu' == $row->action &&
 116                            'core' == $row->location)
 117                         {
 118                                 return true;
 119                         }
 120                 }
 121                 return false;
 122         }
 123
 124         /**
 125          * Communicate that Openid needs configuration if true
 126          *
 127          * If the superuser has not been defined, returns true.
 128          *
 129          * @return boolean True if OpenID still needs to be configured
 130          */
 131         public static function needsConfiguring()
 132         {
 133                 $config = self::_loadConfig();
 134                 if(empty($config->administration->superuser))
 135                 {
 136                         return true;
 137                 }
 138                 return false;
 139         }
 140
 141         /**
 142          * Creates the table in the database and perform the first authentication
 143          *
 144          * @throws Pivip_Install_Exception
 145          * @return boolean Whether the installation succeeded
 146          */
 147         public function install()
 148         {
 149                 if($this->isInstalled())
 150                 {
 151                         return;
 152                 }
 153                 $nextRequest = new Zend_Controller_Request_Simple('index',
 154                                                              'install',
 155                                                              'openid');
 156                 $this->_pushStack($nextRequest);
 157         }
 158
 159         /**
 160          * Remove the table from the database
 161          *
 162          * @throws Pivip_Install_Exception
 163          * @return boolean Whether uninstallation succeeded
 164          */
 165         public function uninstall()
 166         {
 167         }
 168
 169         /**
 170          * Convert OpenID's to cache ID's
 171          *
 172          * @param  string $openid OpenID
 173          * @return string Cache id
 174          */
 175         public static function openidToCacheId($openid)
 176         {
 177                 return 'openid_id_' .  Pivip_Utility_Cache::toCacheId($openid);
 178         }
 179
 180         /**
 181          * Change details retreived using Sreg to the Identity Properties format
 182          *
 183          * @param  array $details Details retrieved using Sreg
 184          * @return array Array containing the Identity Properties
 185          */
 186         public static function sregToProperties(array $details)
 187         {
 188                 if(empty($details['nickname']) || empty($details['id']))
 189                 {
 190                         throw new InvalidArgumentException();
 191                 }
 192                 $data = array('nickname' => $details['nickname'],
 193                               'uid' => $details['id']);
 194                 if(!empty($details['fullname']))
 195                 {
 196                         $data['fn'] = $details['fullname'];
 197                 } else {
 198                         $data['fn'] = $details['nickname'];
 199                 }
 200                 if(!empty($details['email']))
 201                 {
 202                         $data['email'] = $details['email'];
 203                 }
 204                 if(!empty($details['dob']) && 10 == strlen($details['dob']))
 205                 {
 206                         $data['bday'] = $details['dob'];
 207                 }
 208                 if(!empty($details['gender']))
 209                 {
 210                         $data['sex'] = strtolower($details['gender']);
 211                 }
 212                 if(!empty($details['postcode']))
 213                 {
 214                         $data['adr'] = ';;;;;' . $details['postcode'];
 215                 } else {
 216                         $data['adr'] = ';;;;;';
 217                 }
 218                 if(!empty($details['country']))
 219                 {
 220                         $locale = new Zend_Locale();
 221                         $data['adr'] .= ';' . $locale->getCountryTranslation(
 222                                               $details['country']);
 223                 } else {
 224                         $data['adr'] .= ';';
 225                 }
 226                 if(!empty($details['language']))
 227                 {
 228                         $data['locale'] = $details['language'];
 229                         if(!empty($details['country']))
 230                         {
 231                                 $data['locale'] .= '_' . $details['country'];
 232                         }
 233                 }
 234                 if(!empty($details['timezone']))
 235                 {
 236                         $data['tz'] = 'VALUE=text:' . $details['timezone'];
 237                 }
 238                 return $data;
 239         }
 240
 241         /**
 242          * Load the OpenID cache
 243          *
 244          * @return Zend_Cache
 245          */
 246         public static function loadCache()
 247         {
 248                 $cacheConfig = Zend_Registry::get('cacheConfig');
 249                 $options = $cacheConfig->toArray();
 250                 $separator = '';
 251                 if('/' != substr($options['cache']['cache_root'], -1))
 252                 {
 253                         $separator = '/';
 254                 }
 255                 $options['backendOptions']['cache_dir'] = $options['cache']['cache_root']
 256                                                            . $separator
 257                                                            . 'modules/openid';
 258                 $frontendOptions = array('cache_id_prefix' => 'openid_',
 259                                          'automatic_serialization' => true);
 260                 $cache = Zend_Cache::factory('Page',
 261                                              $cacheConfig->cache->backend,
 262                                              $frontendOptions,
 263                                              $options['backendOptions']);
 264                 return $cache;
 265         }
 266
 267         /**
 268          * Load the module
 269          *
 270          * Register the OpenID Authentication adapter with Zend_Auth, process a login
 271          * form if submitted and, if no superuser has been set yet, prompt the user
 272          * to assign one.
 273          *
 274          * @todo Allow the admins to edit the ACL.
 275          * @todo Do not add a block unasked if the Page module is installed
 276          * @todo If the Page module has not yet been installed, load the login form
 277          *       in the main section instead of the menu.
 278          */
 279         public function bootstrap()
 280         {
 281                 // If Pivip has been installed but this module has not,
 282                 // commence installation so we can authenticate and authorize users
 283                 if(!$this->isInstalled())
 284                 {
 285                         if(Install_Module::isInstalled())
 286                         {
 287                                 $this->install();
 288                         }
 289                         return;
 290                 }
 291                 // If the Page module has been installed, make sure that a login
 292                 // form is added
 293                 if(!$this->blockAdded() && Page_Module::isInstalled())
 294                 {
 295                         $nextRequest = new Zend_Controller_Request_Simple('block',
 296                                                                           'install',
 297                                                                           'openid');
 298                         self::_pushStack($nextRequest);
 299                 }
 300                 // If the Page module has not yet been installed, make sure the visitor
 301                 // can login
 302                 if(!Page_Module::isInstalled())
 303                 {
 304                         $nextRequest = new Zend_Controller_Request_Simple('menu',
 305                                                                           'authentication',
 306                                                                           'openid');
 307                         self::_pushStack($nextRequest);
 308                 }
 309                 $request = new Zend_Controller_Request_Http();
 310                 $openid_identifier = $request->getPost('openid_identifier');
 311                 $openid_action = $request->getPost('openid_action');
 312                 $openid_mode = $request->getQuery('openid_mode');
 313                 if(($request->isPost() &&
 314                     !empty($openid_identifier) &&
 315                     !empty($openid_action)) ||
 316                    !empty($openid_mode))
 317                 {
 318                         $nextRequest = new Zend_Controller_Request_Simple('process',
 319                                                                           'authentication',
 320                                                                           'openid');
 321                         self::_pushStack($nextRequest);
 322                 }
 323
 324                 $router = Zend_Controller_Front::getInstance()->getRouter();
 325                 $options = array('module' => 'openid', 'controller' => 'authentication',
 326                                  'action' => 'logout');
 327                 $route = new Zend_Controller_Router_Route_Static('account/logout',
 328                                                                  $options);
 329                 $router->addRoute('openidLogout', $route);
 330         }
 331 }