b2evolution

Multilingual multiuser multiblog engine

b2evolution Technical Documentation (0.9.x) [ class tree: evocore ] [ index: evocore ] [ all elements ]

Source for file _class_user.php

Documentation is available at _class_user.php

  1. <?php
  2. /**
  3.  * This file implements Users
  4.  *
  5.  * b2evolution - {@link http://b2evolution.net/}
  6.  * Released under GNU GPL License - {@link http://b2evolution.net/about/license.html}
  7.  * @copyright (c)2003-2005 by Francois PLANQUE - {@link http://fplanque.net/}
  8.  *
  9.  * @package evocore
  10.  */
  11. if!defined('DB_USER') ) die'Please, do not access this page directly.' );
  12.  
  13. /**
  14.  * Includes:
  15.  */
  16. require_once dirname(__FILE__)'/_class_dataobject.php';
  17.  
  18. /**
  19.  * User Class
  20.  *
  21.  * @package evocore
  22.  */
  23. class User extends DataObject
  24. {
  25.     var    $login;
  26.     var    $pass;
  27.     var    $firstname;
  28.     var    $lastname;
  29.     var    $nickname;
  30.     var    $idmode;
  31.     var    $locale;
  32.     var    $email;
  33.     var    $url;
  34.     var    $icq;
  35.     var    $aim;
  36.     var    $msn;
  37.     var    $yim;
  38.     var    $ip;
  39.     var    $domain;
  40.     var    $browser;
  41.     var    $datecreated;
  42.     var    $level;
  43.     var    $notify;
  44.  
  45.     var $Group;    // Pointer to group
  46.  
  47.     // Blog posts statuses permissions:
  48.     var $blog_post_statuses = array();
  49.  
  50.     /**
  51.      * Constructor
  52.      *
  53.      * {@internal User::User(-)}}
  54.      *
  55.      * @param array existing userdata {@link get_userdata()} 
  56.      */
  57.     function User$userdata NULL )
  58.     {
  59.         global $GroupCache$tableusers$default_locale;
  60.  
  61.         // Call parent constructor:
  62.         parent::DataObject$tableusers'user_' );
  63.  
  64.         if$userdata == NULL )
  65.         {
  66.             // echo 'Creating blank user';
  67.             $this->login = 'login';
  68.             $this->pass = 'pass';
  69.             $this->firstname = '';
  70.             $this->lastname = T_('New user');
  71.             $this->nickname = '';
  72.             $this->idmode = 'login';
  73.             $this->locale = $default_locale;
  74.             $this->email = '';
  75.             $this->url = '';
  76.             $this->icq = 0;
  77.             $this->aim = '';
  78.             $this->msn = '';
  79.             $this->yim = '';
  80.             $this->ip = '';
  81.             $this->domain = '';
  82.             $this->browser = '';
  83.             $this->datecreated = date('Y-m-d H:i:s'time());    // We don't know local time here!
  84.             $this->level = 0;
  85.             $this->notify = 1;
  86.             // Group for this user:
  87.             $this->Group = NULL;
  88.         }
  89.         else
  90.         {
  91.             // echo 'Instanciating existing user';
  92.             $this->ID = $userdata['ID'];
  93.             $this->login = $userdata['user_login'];
  94.             $this->pass = $userdata['user_pass'];
  95.             $this->firstname = $userdata['user_firstname'];
  96.             $this->lastname = $userdata['user_lastname'];
  97.             $this->nickname = $userdata['user_nickname'];
  98.             $this->idmode = $userdata['user_idmode'];
  99.             $this->locale = $userdata['user_locale'];
  100.             $this->email = $userdata['user_email'];
  101.             $this->url = $userdata['user_url'];
  102.             $this->icq = $userdata['user_icq'];
  103.             $this->aim = $userdata['user_aim'];
  104.             $this->msn = $userdata['user_msn'];
  105.             $this->yim = $userdata['user_yim'];
  106.             $this->ip = $userdata['user_ip'];
  107.             $this->domain = $userdata['user_domain'];
  108.             $this->browser = $userdata['user_browser'];
  109.             $this->datecreated = $userdata['dateYMDhour'];
  110.             $this->level = $userdata['user_level'];
  111.             $this->notify = $userdata['user_notify'];
  112.  
  113.             // Group for this user:
  114.             $this->Group = $GroupCache->get_by_ID$userdata['user_grp_ID');
  115.         }
  116.     }
  117.  
  118.     /**
  119.      * Get a param
  120.      *
  121.      * {@internal User::get(-)}}
  122.      */
  123.     function get$parname )
  124.     {
  125.         switch$parname )
  126.         {
  127.             case 'preferedname':
  128.                 // Prefered name to display
  129.                 switch$this->idmode )
  130.                 {
  131.                     case 'namefl':
  132.                         return parent::get('firstname')' 'parent::get('lastname');
  133.  
  134.                     case 'namelf':
  135.                         return parent::get('lastname')' 'parent::get('firstname');
  136.  
  137.                     default:
  138.                         return parent::get($this->idmode);
  139.                 }
  140.  
  141.             case 'num_posts':
  142.                 return get_usernumposts$this->ID );
  143.  
  144.             default:
  145.             // All other params:
  146.                 return parent::get$parname );
  147.         }
  148.     }
  149.  
  150.     /*
  151.      * User::set(-)
  152.      *
  153.      * Set param value
  154.      */
  155.     function set$parname$parvalue )
  156.     {
  157.         switch$parname )
  158.         {
  159.             // case 'icq':        // Dangerous: easy to forget it's not a string
  160.             case 'level':
  161.             case 'notify':
  162.                 parent::set_param$parname'number'$parvalue );
  163.             break;
  164.  
  165.             default:
  166.                 parent::set_param$parname'string'$parvalue );
  167.         }
  168.     }
  169.  
  170.     /*
  171.      * User::set_datecreated(-)
  172.      *
  173.      * Set date created
  174.      */
  175.     function set_datecreated$datecreated )
  176.     {
  177.         // Set value:
  178.         $this->datecreated = date('Y-m-d H:i:s'$datecreated );
  179.         // Remmeber change for later db update:
  180.         $this->dbchange'dateYMDhour' 'string''datecreated' );
  181.     }
  182.  
  183.     /*
  184.      * User::setGroup(-)
  185.      *
  186.      * Set new Group
  187.      */
  188.     function setGroup$Group )
  189.     {
  190.         $this->Group = $Group;
  191.  
  192.         $this->dbchange'user_grp_ID''number''Group->get(\'ID\')' );
  193.     }
  194.  
  195.     /**
  196.      * Check permission for this user
  197.      *
  198.      * {@internal User::check_perm(-) }}
  199.      *
  200.      * @param string Permission name, can be one of:
  201.      *                                 - 'upload'
  202.      *                                 - 'edit_timestamp'
  203.      *                                 - 'cats_post_statuses', see {@link User::check_perm_catsusers()}
  204.      *                                 - either group permission names, see {@link Group::check_perm()}
  205.      *                                 - either blogusers permission names, see {@link User::check_perm_blogusers()}
  206.      * @param string Permission level
  207.      * @param boolean Execution will halt if this is !0 and permission is denied
  208.      * @param mixed Permission target (blog ID, array of cat IDs...)
  209.      * @return boolean 0 if permission denied
  210.      */
  211.     function check_perm$permname$permlevel 'any'$assert false$perm_target NULL )
  212.     {
  213.         global $use_fileupload$fileupload_minlevel$fileupload_allowedusers;
  214.  
  215.         $perm false;
  216.  
  217.         switch$permname )
  218.         // What permission do we want to check?
  219.             case 'upload':
  220.                 // Global permission to upload files...
  221.                 $perm (($use_fileupload&& ($this->level>= $fileupload_minlevel)
  222.                                 && ((ereg(' '$this->login' '$fileupload_allowedusers)) || (trim($fileupload_allowedusers)==''));
  223.                 break;
  224.  
  225.             case 'edit_timestamp':
  226.                 // Global permission to edit timestamps...
  227.                 $perm ($this->level >= 5);
  228.                 break;
  229.  
  230.             case 'cats_post_statuses':
  231.                 // Category permissions...
  232.                 $perm $this->check_perm_catsusers$permname$permlevel$perm_target );
  233.                 break;
  234.  
  235.             case 'blog_properties':
  236.                 // Blog permission to edit its properties... (depending on user AND hits group)
  237.                 // Forward request to group:
  238.                 if$this->Group->check_perm'blogs'$permlevel ) )
  239.                 {    // If group says yes
  240.                     $perm true;
  241.                     break;
  242.                 }
  243.                 if$perm_target )
  244.                 // Check user perm for this blog
  245.                     $perm $this->check_perm_blogusers$permname$permlevel$perm_target );
  246.                 }
  247.                 break;
  248.  
  249.             case 'blog_ismember':
  250.             case 'blog_post_statuses':
  251.             case 'blog_del_post':
  252.             case 'blog_comments':
  253.             case 'blog_cats':
  254.             case 'blog_genstatic':
  255.                 // Blog permission to this or that... (depending on this user only)
  256.                 $perm $this->check_perm_blogusers$permname$permlevel$perm_target );
  257.                 break;
  258.  
  259.             default:
  260.                 // Other global permissions (see if the group can handle them)
  261.                 // Forward request to group:
  262.                 $perm $this->Group->check_perm$permname$permlevel );
  263.         }
  264.  
  265.         if!$perm && $assert )
  266.         // We can't let this go on!
  267.             dieT_('Permission denied!')' ('$permname '/'$permlevel ')' );
  268.         }
  269.  
  270.         return $perm;
  271.     }
  272.  
  273.  
  274.     /**
  275.      * Check permission for this user on a set of specified categories
  276.      *
  277.      * This is not for direct use, please call {@link User::check_perm()} instead
  278.      *
  279.      * {@internal User::check_perm_catsusers(-) }}
  280.      *
  281.      * @see User::check_perm()
  282.      * @param string Permission name, can be one of the following:
  283.      *                                     - cat_post_statuses
  284.      *                                     - more to come later...
  285.      * @param string Permission level
  286.      * @param array Array of target cat IDs
  287.      * @return boolean 0 if permission denied
  288.      */
  289.     function check_perm_catsusers$permname$permlevel$perm_target_cats )
  290.     {
  291.         // Check if permission is granted:
  292.         switch$permname )
  293.         {
  294.             case 'cats_post_statuses':
  295.                 // We'll actually pass this on to blog permissions
  296.                 // First we need to create an array of blogs, not cats
  297.                 $perm_target_blogs array();
  298.                 foreach$perm_target_cats as $loop_cat_ID )
  299.                 {
  300.                     $loop_cat_blog_ID get_catblog$loop_cat_ID );
  301.                     // echo "cat $loop_cat_ID -> blog $loop_cat_blog_ID <br/>";
  302.                     ifin_array$loop_cat_blog_ID$perm_target_blogs ) )
  303.                     {    // not already in list: add it:
  304.                         $perm_target_blogs[$loop_cat_blog_ID;
  305.                     }
  306.                 }
  307.                 // Now we'll check permissions for each blog:
  308.                 foreach$perm_target_blogs as $loop_blog_ID )
  309.                 {
  310.                     if$this->check_perm_blogusers'blog_post_statuses'$permlevel$loop_blog_ID ) )
  311.                     {    // If at least one blog is denied:
  312.                         return false;    // permission denied
  313.                     }
  314.                 }
  315.                 return true;    // Permission granted
  316.         }
  317.  
  318.         return false;     // permission denied
  319.     }
  320.  
  321.  
  322.     /**
  323.      * Check permission for this user on a specified blog
  324.      *
  325.      * This is not for direct use, please call {@link User::check_perm()} instead
  326.      *
  327.      * {@internal User::check_perm_blogusers(-) }}
  328.      *
  329.      * @see User::check_perm()
  330.      * @param string Permission name, can be one of the following:
  331.      *                                     - blog_ismember
  332.      *                                     - blog_post_statuses
  333.      *                                     - blog_del_post
  334.      *                                     - blog_comments
  335.      *                                     - blog_cats
  336.      *                                     - blog_properties
  337.      *                                     - blog_genstatic
  338.      * @param string Permission level
  339.      * @param integer Permission target blog ID
  340.      * @return boolean 0 if permission denied
  341.      */
  342.     function check_perm_blogusers$permname$permlevel$perm_target_blog )
  343.     {
  344.         global $DB$tableblogusers;
  345.         // echo "checkin for $permname >= $permlevel on blog $perm_target_blog<br />";
  346.  
  347.         if!isset$this->blog_post_statuses[$perm_target_blog) )
  348.         {    // Allowed blog post statuses have not been loaded yet:
  349.             if$this->ID == )
  350.             {    // User not in DB, nothing to load!:
  351.                 return false;    // Permission denied
  352.             }
  353.  
  354.             // Load now:
  355.             // echo 'loading allowed statuses';
  356.             $query "SELECT *
  357.                                 FROM $tableblogusers
  358.                                 WHERE bloguser_blog_ID = $perm_target_blog
  359.                                   AND bloguser_user_ID = $this->ID";
  360.             // echo $query, '<br />';
  361.             if( ($row $DB->get_row$queryARRAY_A )) == NULL )
  362.             {    // No rights set for this Blog/User
  363.                 return false;    // Permission denied
  364.             }
  365.             else
  366.             // OK, rights found:
  367.                 $this->blog_post_statuses[$perm_target_blogarray();
  368.  
  369.                 $this->blog_post_statuses[$perm_target_blog]['blog_ismember'$row['bloguser_ismember'];
  370.  
  371.                 $bloguser_perm_post $row['bloguser_perm_poststatuses'];
  372.                 ifempty($bloguser_perm_post ) )
  373.                     $this->blog_post_statuses[$perm_target_blog]['blog_post_statuses'array();
  374.                 else
  375.                     $this->blog_post_statuses[$perm_target_blog]['blog_post_statuses'explode','$bloguser_perm_post );
  376.  
  377.                 $this->blog_post_statuses[$perm_target_blog]['blog_del_post'$row['bloguser_perm_delpost'];
  378.                 $this->blog_post_statuses[$perm_target_blog]['blog_comments'$row['bloguser_perm_comments'];
  379.                 $this->blog_post_statuses[$perm_target_blog]['blog_cats'$row['bloguser_perm_cats'];
  380.                 $this->blog_post_statuses[$perm_target_blog]['blog_properties'$row['bloguser_perm_properties'];
  381.             }
  382.         }
  383.  
  384.         // Check if permission is granted:
  385.         switch$permname )
  386.         {
  387.             case 'blog_genstatic':
  388.                 return ($this->level >= 2);
  389.  
  390.             case 'blog_post_statuses':
  391.                 if$permlevel == 'any' )
  392.                 // Any prermission will do:
  393.                     // echo count($this->blog_post_statuses);
  394.                     return count($this->blog_post_statuses[$perm_target_blog]['blog_post_statuses']);
  395.                 }
  396.  
  397.                 // We want a specific permission:
  398.                 // echo 'checking :', implode( ',', $this->blog_post_statuses  ), '<br />';
  399.                 return in_array$permlevel$this->blog_post_statuses[$perm_target_blog]['blog_post_statuses');
  400.  
  401.             default:
  402.                 // echo $permname, '=', $this->blog_post_statuses[$perm_target_blog][$permname], ' ';
  403.                 return $this->blog_post_statuses[$perm_target_blog][$permname];
  404.         }
  405.     }
  406.  
  407.  
  408.     /**
  409.      * Delete user and dependencies from database
  410.      *
  411.      * Includes WAY TOO MANY requests because we try to be compatible with mySQL 3.23, bleh!
  412.      *
  413.      * {@internal User::dbdelete(-) }}
  414.      *
  415.      * @todo delete comments on user's posts
  416.      *
  417.      * @param boolean true if you want to echo progress
  418.      */
  419.     function dbdelete$echo false )
  420.     {
  421.         global $DB$tablecomments$tableposts$tablepostcats$tableblogusers;
  422.  
  423.         if$this->ID == die'Non persistant object cannot be deleted!' );
  424.  
  425.         // Note: No need to localize the status messages...
  426.         if$echo echo '<p>mySQL 3.23 compatibility mode!';
  427.  
  428.         // Transform registered user comments to unregistered:
  429.         if$echo echo '<br />Transforming user\'s comments to unregistered comments... ';
  430.         $ret $DB->query"UPDATE $tablecomments
  431.                                                 SET comment_author_ID = NULL,
  432.                                                         comment_author = ".$DB->quote$this->get('preferedname') ).",
  433.                                                         comment_author_email = ".$DB->quote$this->get('email') ).",
  434.                                                         comment_author_url = ".$DB->quote$this->get('url') )."
  435.                                                 WHERE comment_author_ID = $this->ID" );
  436.         if$echo printf'(%d rows)'$ret );
  437.  
  438.         // Get list of posts that are going to be deleted (3.23)
  439.         if$echo echo '<br />Getting post list to delete... ';
  440.         $post_list $DB->get_list"SELECT ID
  441.                                                                     FROM $tableposts
  442.                                                                     WHERE post_author = $this->ID" );
  443.  
  444.         ifempty$post_list ) )
  445.         {
  446.             echo 'None!';
  447.         }
  448.         else
  449.         {
  450.             // Delete comments
  451.             if$echo echo '<br />Deleting comments on user\'s posts... ';
  452.             $ret $DB->query"DELETE FROM $tablecomments
  453.                                                     WHERE comment_post_ID IN ($post_list));
  454.             if$echo printf'(%d rows)'$ret );
  455.  
  456.             // Delete post extracats
  457.             if$echo echo '<br />Deleting user\'s posts\' extracats... ';
  458.             $ret $DB->query(    "DELETE FROM $tablepostcats
  459.                                                     WHERE postcat_post_ID IN ($post_list));
  460.             if$echo printf'(%d rows)'$ret );
  461.  
  462.             // Delete posts
  463.             if$echo echo '<br />Deleting user\'s posts... ';
  464.             $ret $DB->query(    "DELETE FROM $tableposts
  465.                                                         WHERE post_author = $this->ID" );
  466.             if$echo printf'(%d rows)'$ret );
  467.         // no posts
  468.  
  469.         // Delete userblog permissions
  470.         if$echo echo '<br />Deleting user-blog permissions... ';
  471.         $ret $DB->query(    "DELETE FROM $tableblogusers
  472.                                                     WHERE bloguser_user_ID = $this->ID" );
  473.         if$echo printf'(%d rows)'$ret );
  474.  
  475.         // Delete main object:
  476.         if$echo echo '<br />Deleting User... ';
  477.         parent::dbdelete();
  478.  
  479.         echo '<br/>Done.</p>';
  480.     }
  481.  
  482.  
  483.     /**
  484.      * Template function: display user's level
  485.      *
  486.      * {@internal User::level(-) }}
  487.      */
  488.     function level()
  489.     {
  490.         $this->disp'level''raw' );
  491.     }
  492.  
  493.  
  494.     /**
  495.      * Template function: display user's login
  496.      *
  497.      * {@internal User::login(-) }}
  498.      *
  499.      * @param string Output format, see {@link format_to_output()}
  500.      */
  501.     function login$format 'htmlbody' )
  502.     {
  503.         $this->disp'login'$format );
  504.     }
  505.  
  506.  
  507.     /**
  508.      * Template function: display user's prefered name
  509.      *
  510.      * {@internal User::prefered_name(-) }}
  511.      *
  512.      * @param string Output format, see {@link format_to_output()}
  513.      */
  514.     function prefered_name$format 'htmlbody' )
  515.     {
  516.         $this->disp'preferedname'$format );
  517.     }
  518.  
  519.     /**
  520.      * Template function: display user's URL
  521.      *
  522.      * {@internal User::url(-) }}
  523.      *
  524.      * @param string string to display before the date (if changed)
  525.      * @param string string to display after the date (if changed)
  526.      * @param string Output format, see {@link format_to_output()}
  527.      */
  528.     function url$before ''$after ''$format 'htmlbody' )
  529.     {
  530.         if!empty$this->url ) )
  531.         {
  532.             echo $before;
  533.             $this->disp'url'$format );
  534.             echo $after;
  535.         }
  536.     }
  537.  
  538. }
  539. ?>

Documentation generated on Tue, 20 May 2008 01:53:40 +0200 by phpDocumentor 1.4.2