[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   * WordPress Roles and Capabilities.
   4   *
   5   * @package WordPress
   6   * @subpackage User
   7   */
   8  
   9  /**
  10   * WordPress User Roles.
  11   *
  12   * The role option is simple, the structure is organized by role name that store
  13   * the name in value of the 'name' key. The capabilities are stored as an array
  14   * in the value of the 'capability' key.
  15   *
  16   * <code>
  17   * array (
  18   *        'rolename' => array (
  19   *            'name' => 'rolename',
  20   *            'capabilities' => array()
  21   *        )
  22   * )
  23   * </code>
  24   *
  25   * @since 2.0.0
  26   * @package WordPress
  27   * @subpackage User
  28   */
  29  class WP_Roles {
  30      /**
  31       * List of roles and capabilities.
  32       *
  33       * @since 2.0.0
  34       * @access public
  35       * @var array
  36       */
  37      var $roles;
  38  
  39      /**
  40       * List of the role objects.
  41       *
  42       * @since 2.0.0
  43       * @access public
  44       * @var array
  45       */
  46      var $role_objects = array();
  47  
  48      /**
  49       * List of role names.
  50       *
  51       * @since 2.0.0
  52       * @access public
  53       * @var array
  54       */
  55      var $role_names = array();
  56  
  57      /**
  58       * Option name for storing role list.
  59       *
  60       * @since 2.0.0
  61       * @access public
  62       * @var string
  63       */
  64      var $role_key;
  65  
  66      /**
  67       * Whether to use the database for retrieval and storage.
  68       *
  69       * @since 2.1.0
  70       * @access public
  71       * @var bool
  72       */
  73      var $use_db = true;
  74  
  75      /**
  76       * PHP4 Constructor - Call {@link WP_Roles::_init()} method.
  77       *
  78       * @since 2.0.0
  79       * @access public
  80       *
  81       * @return WP_Roles
  82       */
  83  	function WP_Roles() {
  84          $this->_init();
  85      }
  86  
  87      /**
  88       * Setup the object properties.
  89       *
  90       * The role key is set to the current prefix for the $wpdb object with
  91       * 'user_roles' appended. If the $wp_user_roles global is set, then it will
  92       * be used and the role option will not be updated or used.
  93       *
  94       * @since 2.1.0
  95       * @access protected
  96       * @uses $wpdb Used to get the database prefix.
  97       * @global array $wp_user_roles Used to set the 'roles' property value.
  98       */
  99  	function _init () {
 100          global $wpdb;
 101          global $wp_user_roles;
 102          $this->role_key = $wpdb->prefix . 'user_roles';
 103          if ( ! empty( $wp_user_roles ) ) {
 104              $this->roles = $wp_user_roles;
 105              $this->use_db = false;
 106          } else {
 107              $this->roles = get_option( $this->role_key );
 108          }
 109  
 110          if ( empty( $this->roles ) )
 111              return;
 112  
 113          $this->role_objects = array();
 114          $this->role_names =  array();
 115          foreach ( (array) $this->roles as $role => $data ) {
 116              $this->role_objects[$role] = new WP_Role( $role, $this->roles[$role]['capabilities'] );
 117              $this->role_names[$role] = $this->roles[$role]['name'];
 118          }
 119      }
 120  
 121      /**
 122       * Add role name with capabilities to list.
 123       *
 124       * Updates the list of roles, if the role doesn't already exist.
 125       *
 126       * The capabilities are defined in the following format `array( 'read' => true );`
 127       * To explicitly deny a role a capability you set the value for that capability to false.
 128       * 
 129       * @since 2.0.0
 130       * @access public
 131       *
 132       * @param string $role Role name.
 133       * @param string $display_name Role display name.
 134       * @param array $capabilities List of role capabilities in the above format.
 135       * @return null|WP_Role WP_Role object if role is added, null if already exists.
 136       */
 137  	function add_role( $role, $display_name, $capabilities = array() ) {
 138          if ( isset( $this->roles[$role] ) )
 139              return;
 140  
 141          $this->roles[$role] = array(
 142              'name' => $display_name,
 143              'capabilities' => $capabilities
 144              );
 145          if ( $this->use_db )
 146              update_option( $this->role_key, $this->roles );
 147          $this->role_objects[$role] = new WP_Role( $role, $capabilities );
 148          $this->role_names[$role] = $display_name;
 149          return $this->role_objects[$role];
 150      }
 151  
 152      /**
 153       * Remove role by name.
 154       *
 155       * @since 2.0.0
 156       * @access public
 157       *
 158       * @param string $role Role name.
 159       */
 160  	function remove_role( $role ) {
 161          if ( ! isset( $this->role_objects[$role] ) )
 162              return;
 163  
 164          unset( $this->role_objects[$role] );
 165          unset( $this->role_names[$role] );
 166          unset( $this->roles[$role] );
 167  
 168          if ( $this->use_db )
 169              update_option( $this->role_key, $this->roles );
 170      }
 171  
 172      /**
 173       * Add capability to role.
 174       *
 175       * @since 2.0.0
 176       * @access public
 177       *
 178       * @param string $role Role name.
 179       * @param string $cap Capability name.
 180       * @param bool $grant Optional, default is true. Whether role is capable of performing capability.
 181       */
 182  	function add_cap( $role, $cap, $grant = true ) {
 183          $this->roles[$role]['capabilities'][$cap] = $grant;
 184          if ( $this->use_db )
 185              update_option( $this->role_key, $this->roles );
 186      }
 187  
 188      /**
 189       * Remove capability from role.
 190       *
 191       * @since 2.0.0
 192       * @access public
 193       *
 194       * @param string $role Role name.
 195       * @param string $cap Capability name.
 196       */
 197  	function remove_cap( $role, $cap ) {
 198          unset( $this->roles[$role]['capabilities'][$cap] );
 199          if ( $this->use_db )
 200              update_option( $this->role_key, $this->roles );
 201      }
 202  
 203      /**
 204       * Retrieve role object by name.
 205       *
 206       * @since 2.0.0
 207       * @access public
 208       *
 209       * @param string $role Role name.
 210       * @return object|null Null, if role does not exist. WP_Role object, if found.
 211       */
 212      function &get_role( $role ) {
 213          if ( isset( $this->role_objects[$role] ) )
 214              return $this->role_objects[$role];
 215          else
 216              return null;
 217      }
 218  
 219      /**
 220       * Retrieve list of role names.
 221       *
 222       * @since 2.0.0
 223       * @access public
 224       *
 225       * @return array List of role names.
 226       */
 227  	function get_names() {
 228          return $this->role_names;
 229      }
 230  
 231      /**
 232       * Whether role name is currently in the list of available roles.
 233       *
 234       * @since 2.0.0
 235       * @access public
 236       *
 237       * @param string $role Role name to look up.
 238       * @return bool
 239       */
 240  	function is_role( $role )
 241      {
 242          return isset( $this->role_names[$role] );
 243      }
 244  }
 245  
 246  /**
 247   * WordPress Role class.
 248   *
 249   * @since 2.0.0
 250   * @package WordPress
 251   * @subpackage User
 252   */
 253  class WP_Role {
 254      /**
 255       * Role name.
 256       *
 257       * @since 2.0.0
 258       * @access public
 259       * @var string
 260       */
 261      var $name;
 262  
 263      /**
 264       * List of capabilities the role contains.
 265       *
 266       * @since 2.0.0
 267       * @access public
 268       * @var array
 269       */
 270      var $capabilities;
 271  
 272      /**
 273       * PHP4 Constructor - Setup object properties.
 274       *
 275       * The list of capabilities, must have the key as the name of the capability
 276       * and the value a boolean of whether it is granted to the role or not.
 277       *
 278       * @since 2.0.0
 279       * @access public
 280       *
 281       * @param string $role Role name.
 282       * @param array $capabilities List of capabilities.
 283       * @return WP_Role
 284       */
 285  	function WP_Role( $role, $capabilities ) {
 286          $this->name = $role;
 287          $this->capabilities = $capabilities;
 288      }
 289  
 290      /**
 291       * Assign role a capability.
 292       *
 293       * @see WP_Roles::add_cap() Method uses implementation for role.
 294       * @since 2.0.0
 295       * @access public
 296       *
 297       * @param string $cap Capability name.
 298       * @param bool $grant Whether role has capability privilege.
 299       */
 300  	function add_cap( $cap, $grant = true ) {
 301          global $wp_roles;
 302  
 303          if ( ! isset( $wp_roles ) )
 304              $wp_roles = new WP_Roles();
 305  
 306          $this->capabilities[$cap] = $grant;
 307          $wp_roles->add_cap( $this->name, $cap, $grant );
 308      }
 309  
 310      /**
 311       * Remove capability from role.
 312       *
 313       * This is a container for {@link WP_Roles::remove_cap()} to remove the
 314       * capability from the role. That is to say, that {@link
 315       * WP_Roles::remove_cap()} implements the functionality, but it also makes
 316       * sense to use this class, because you don't need to enter the role name.
 317       *
 318       * @since 2.0.0
 319       * @access public
 320       *
 321       * @param string $cap Capability name.
 322       */
 323  	function remove_cap( $cap ) {
 324          global $wp_roles;
 325  
 326          if ( ! isset( $wp_roles ) )
 327              $wp_roles = new WP_Roles();
 328  
 329          unset( $this->capabilities[$cap] );
 330          $wp_roles->remove_cap( $this->name, $cap );
 331      }
 332  
 333      /**
 334       * Whether role has capability.
 335       *
 336       * The capabilities is passed through the 'role_has_cap' filter. The first
 337       * parameter for the hook is the list of capabilities the class has
 338       * assigned. The second parameter is the capability name to look for. The
 339       * third and final parameter for the hook is the role name.
 340       *
 341       * @since 2.0.0
 342       * @access public
 343       *
 344       * @param string $cap Capability name.
 345       * @return bool True, if user has capability. False, if doesn't have capability.
 346       */
 347  	function has_cap( $cap ) {
 348          $capabilities = apply_filters( 'role_has_cap', $this->capabilities, $cap, $this->name );
 349          if ( !empty( $capabilities[$cap] ) )
 350              return $capabilities[$cap];
 351          else
 352              return false;
 353      }
 354  
 355  }
 356  
 357  /**
 358   * WordPress User class.
 359   *
 360   * @since 2.0.0
 361   * @package WordPress
 362   * @subpackage User
 363   */
 364  class WP_User {
 365      /**
 366       * User data container.
 367       *
 368       * This will be set as properties of the object.
 369       *
 370       * @since 2.0.0
 371       * @access private
 372       * @var array
 373       */
 374      var $data;
 375  
 376      /**
 377       * The user's ID.
 378       *
 379       * @since 2.1.0
 380       * @access public
 381       * @var int
 382       */
 383      var $ID = 0;
 384  
 385      /**
 386       * The deprecated user's ID.
 387       *
 388       * @since 2.0.0
 389       * @access public
 390       * @deprecated Use WP_User::$ID
 391       * @see WP_User::$ID
 392       * @var int
 393       */
 394      var $id = 0;
 395  
 396      /**
 397       * The individual capabilities the user has been given.
 398       *
 399       * @since 2.0.0
 400       * @access public
 401       * @var array
 402       */
 403      var $caps = array();
 404  
 405      /**
 406       * User metadata option name.
 407       *
 408       * @since 2.0.0
 409       * @access public
 410       * @var string
 411       */
 412      var $cap_key;
 413  
 414      /**
 415       * The roles the user is part of.
 416       *
 417       * @since 2.0.0
 418       * @access public
 419       * @var array
 420       */
 421      var $roles = array();
 422  
 423      /**
 424       * All capabilities the user has, including individual and role based.
 425       *
 426       * @since 2.0.0
 427       * @access public
 428       * @var array
 429       */
 430      var $allcaps = array();
 431  
 432      /**
 433       * First name of the user.
 434       *
 435       * Created to prevent notices.
 436       *
 437       * @since 2.7.0
 438       * @access public
 439       * @var string
 440       */
 441      var $first_name = '';
 442  
 443      /**
 444       * Last name of the user.
 445       *
 446       * Created to prevent notices.
 447       *
 448       * @since 2.7.0
 449       * @access public
 450       * @var string
 451       */
 452      var $last_name = '';
 453  
 454      /**
 455       * The filter context applied to user data fields.
 456       *
 457       * @since 2.9.0
 458       * @access private
 459       * @var string
 460       */
 461      var $filter = null;
 462  
 463      /**
 464       * PHP4 Constructor - Sets up the object properties.
 465       *
 466       * Retrieves the userdata and then assigns all of the data keys to direct
 467       * properties of the object. Calls {@link WP_User::_init_caps()} after
 468       * setting up the object's user data properties.
 469       *
 470       * @since 2.0.0
 471       * @access public
 472       *
 473       * @param int|string $id User's ID or username
 474       * @param int $name Optional. User's username
 475       * @return WP_User
 476       */
 477  	function WP_User( $id, $name = '' ) {
 478  
 479          if ( empty( $id ) && empty( $name ) )
 480              return;
 481  
 482          if ( ! is_numeric( $id ) ) {
 483              $name = $id;
 484              $id = 0;
 485          }
 486  
 487          if ( ! empty( $id ) )
 488              $this->data = get_userdata( $id );
 489          else
 490              $this->data = get_userdatabylogin( $name );
 491  
 492          if ( empty( $this->data->ID ) )
 493              return;
 494  
 495          foreach ( get_object_vars( $this->data ) as $key => $value ) {
 496              $this->{$key} = $value;
 497          }
 498  
 499          $this->id = $this->ID;
 500          $this->_init_caps();
 501      }
 502  
 503      /**
 504       * Setup capability object properties.
 505       *
 506       * Will set the value for the 'cap_key' property to current database table
 507       * prefix, followed by 'capabilities'. Will then check to see if the
 508       * property matching the 'cap_key' exists and is an array. If so, it will be
 509       * used.
 510       *
 511       * @since 2.1.0
 512       * @access protected
 513       */
 514  	function _init_caps() {
 515          global $wpdb;
 516          $this->cap_key = $wpdb->prefix . 'capabilities';
 517          $this->caps = &$this->{$this->cap_key};
 518          if ( ! is_array( $this->caps ) )
 519              $this->caps = array();
 520          $this->get_role_caps();
 521      }
 522  
 523      /**
 524       * Retrieve all of the role capabilities and merge with individual capabilities.
 525       *
 526       * All of the capabilities of the roles the user belongs to are merged with
 527       * the users individual roles. This also means that the user can be denied
 528       * specific roles that their role might have, but the specific user isn't
 529       * granted permission to.
 530       *
 531       * @since 2.0.0
 532       * @uses $wp_roles
 533       * @access public
 534       */
 535  	function get_role_caps() {
 536          global $wp_roles;
 537  
 538          if ( ! isset( $wp_roles ) )
 539              $wp_roles = new WP_Roles();
 540  
 541          //Filter out caps that are not role names and assign to $this->roles
 542          if ( is_array( $this->caps ) )
 543              $this->roles = array_filter( array_keys( $this->caps ), array( &$wp_roles, 'is_role' ) );
 544  
 545          //Build $allcaps from role caps, overlay user's $caps
 546          $this->allcaps = array();
 547          foreach ( (array) $this->roles as $role ) {
 548              $role =& $wp_roles->get_role( $role );
 549              $this->allcaps = array_merge( (array) $this->allcaps, (array) $role->capabilities );
 550          }
 551          $this->allcaps = array_merge( (array) $this->allcaps, (array) $this->caps );
 552      }
 553  
 554      /**
 555       * Add role to user.
 556       *
 557       * Updates the user's meta data option with capabilities and roles.
 558       *
 559       * @since 2.0.0
 560       * @access public
 561       *
 562       * @param string $role Role name.
 563       */
 564  	function add_role( $role ) {
 565          $this->caps[$role] = true;
 566          update_usermeta( $this->ID, $this->cap_key, $this->caps );
 567          $this->get_role_caps();
 568          $this->update_user_level_from_caps();
 569      }
 570  
 571      /**
 572       * Remove role from user.
 573       *
 574       * @since 2.0.0
 575       * @access public
 576       *
 577       * @param string $role Role name.
 578       */
 579  	function remove_role( $role ) {
 580          if ( empty( $this->roles[$role] ) || ( count( $this->roles ) <= 1 ) )
 581              return;
 582          unset( $this->caps[$role] );
 583          update_usermeta( $this->ID, $this->cap_key, $this->caps );
 584          $this->get_role_caps();
 585      }
 586  
 587      /**
 588       * Set the role of the user.
 589       *
 590       * This will remove the previous roles of the user and assign the user the
 591       * new one. You can set the role to an empty string and it will remove all
 592       * of the roles from the user.
 593       *
 594       * @since 2.0.0
 595       * @access public
 596       *
 597       * @param string $role Role name.
 598       */
 599  	function set_role( $role ) {
 600          foreach ( (array) $this->roles as $oldrole )
 601              unset( $this->caps[$oldrole] );
 602          if ( !empty( $role ) ) {
 603              $this->caps[$role] = true;
 604              $this->roles = array( $role => true );
 605          } else {
 606              $this->roles = false;
 607          }
 608          update_usermeta( $this->ID, $this->cap_key, $this->caps );
 609          $this->get_role_caps();
 610          $this->update_user_level_from_caps();
 611          do_action( 'set_user_role', $this->ID, $role );
 612      }
 613  
 614      /**
 615       * Choose the maximum level the user has.
 616       *
 617       * Will compare the level from the $item parameter against the $max
 618       * parameter. If the item is incorrect, then just the $max parameter value
 619       * will be returned.
 620       *
 621       * Used to get the max level based on the capabilities the user has. This
 622       * is also based on roles, so if the user is assigned the Administrator role
 623       * then the capability 'level_10' will exist and the user will get that
 624       * value.
 625       *
 626       * @since 2.0.0
 627       * @access public
 628       *
 629       * @param int $max Max level of user.
 630       * @param string $item Level capability name.
 631       * @return int Max Level.
 632       */
 633  	function level_reduction( $max, $item ) {
 634          if ( preg_match( '/^level_(10|[0-9])$/i', $item, $matches ) ) {
 635              $level = intval( $matches[1] );
 636              return max( $max, $level );
 637          } else {
 638              return $max;
 639          }
 640      }
 641  
 642      /**
 643       * Update the maximum user level for the user.
 644       *
 645       * Updates the 'user_level' user metadata (includes prefix that is the
 646       * database table prefix) with the maximum user level. Gets the value from
 647       * the all of the capabilities that the user has.
 648       *
 649       * @since 2.0.0
 650       * @access public
 651       */
 652  	function update_user_level_from_caps() {
 653          global $wpdb;
 654          $this->user_level = array_reduce( array_keys( $this->allcaps ), array( &$this, 'level_reduction' ), 0 );
 655          update_usermeta( $this->ID, $wpdb->prefix.'user_level', $this->user_level );
 656      }
 657  
 658      /**
 659       * Add capability and grant or deny access to capability.
 660       *
 661       * @since 2.0.0
 662       * @access public
 663       *
 664       * @param string $cap Capability name.
 665       * @param bool $grant Whether to grant capability to user.
 666       */
 667  	function add_cap( $cap, $grant = true ) {
 668          $this->caps[$cap] = $grant;
 669          update_usermeta( $this->ID, $this->cap_key, $this->caps );
 670      }
 671  
 672      /**
 673       * Remove capability from user.
 674       *
 675       * @since 2.0.0
 676       * @access public
 677       *
 678       * @param string $cap Capability name.
 679       */
 680  	function remove_cap( $cap ) {
 681          if ( empty( $this->caps[$cap] ) ) return;
 682          unset( $this->caps[$cap] );
 683          update_usermeta( $this->ID, $this->cap_key, $this->caps );
 684      }
 685  
 686      /**
 687       * Remove all of the capabilities of the user.
 688       *
 689       * @since 2.1.0
 690       * @access public
 691       */
 692  	function remove_all_caps() {
 693          global $wpdb;
 694          $this->caps = array();
 695          update_usermeta( $this->ID, $this->cap_key, '' );
 696          update_usermeta( $this->ID, $wpdb->prefix.'user_level', '' );
 697          $this->get_role_caps();
 698      }
 699  
 700      /**
 701       * Whether user has capability or role name.
 702       *
 703       * This is useful for looking up whether the user has a specific role
 704       * assigned to the user. The second optional parameter can also be used to
 705       * check for capabilities against a specfic post.
 706       *
 707       * @since 2.0.0
 708       * @access public
 709       *
 710       * @param string|int $cap Capability or role name to search.
 711       * @param int $post_id Optional. Post ID to check capability against specific post.
 712       * @return bool True, if user has capability; false, if user does not have capability.
 713       */
 714  	function has_cap( $cap ) {
 715          if ( is_numeric( $cap ) )
 716              $cap = $this->translate_level_to_cap( $cap );
 717  
 718          $args = array_slice( func_get_args(), 1 );
 719          $args = array_merge( array( $cap, $this->ID ), $args );
 720          $caps = call_user_func_array( 'map_meta_cap', $args );
 721          // Must have ALL requested caps
 722          $capabilities = apply_filters( 'user_has_cap', $this->allcaps, $caps, $args );
 723          foreach ( (array) $caps as $cap ) {
 724              //echo "Checking cap $cap<br />";
 725              if ( empty( $capabilities[$cap] ) || !$capabilities[$cap] )
 726                  return false;
 727          }
 728  
 729          return true;
 730      }
 731  
 732      /**
 733       * Convert numeric level to level capability name.
 734       *
 735       * Prepends 'level_' to level number.
 736       *
 737       * @since 2.0.0
 738       * @access public
 739       *
 740       * @param int $level Level number, 1 to 10.
 741       * @return string
 742       */
 743  	function translate_level_to_cap( $level ) {
 744          return 'level_' . $level;
 745      }
 746  
 747  }
 748  
 749  /**
 750   * Map meta capabilities to primitive capabilities.
 751   *
 752   * This does not actually compare whether the user ID has the actual capability,
 753   * just what the capability or capabilities are. Meta capability list value can
 754   * be 'delete_user', 'edit_user', 'delete_post', 'delete_page', 'edit_post',
 755   * 'edit_page', 'read_post', or 'read_page'.
 756   *
 757   * @since 2.0.0
 758   *
 759   * @param string $cap Capability name.
 760   * @param int $user_id User ID.
 761   * @return array Actual capabilities for meta capability.
 762   */
 763  function map_meta_cap( $cap, $user_id ) {
 764      $args = array_slice( func_get_args(), 2 );
 765      $caps = array();
 766  
 767      switch ( $cap ) {
 768      case 'delete_user':
 769          $caps[] = 'delete_users';
 770          break;
 771      case 'edit_user':
 772          if ( !isset( $args[0] ) || $user_id != $args[0] ) {
 773              $caps[] = 'edit_users';
 774          }
 775          break;
 776      case 'delete_post':
 777          $author_data = get_userdata( $user_id );
 778          //echo "post ID: {$args[0]}<br />";
 779          $post = get_post( $args[0] );
 780          if ( 'page' == $post->post_type ) {
 781              $args = array_merge( array( 'delete_page', $user_id ), $args );
 782              return call_user_func_array( 'map_meta_cap', $args );
 783          }
 784  
 785          if ('' != $post->post_author) {
 786              $post_author_data = get_userdata( $post->post_author );
 787          } else {
 788              //No author set yet so default to current user for cap checks
 789              $post_author_data = $author_data;
 790          }
 791  
 792          // If the user is the author...
 793          if ( $user_id == $post_author_data->ID ) {
 794              // If the post is published...
 795              if ( 'publish' == $post->post_status ) {
 796                  $caps[] = 'delete_published_posts';
 797              } elseif ( 'trash' == $post->post_status ) {
 798                  if ('publish' == get_post_meta($post->ID, '_wp_trash_meta_status', true) )
 799                      $caps[] = 'delete_published_posts';
 800              } else {
 801                  // If the post is draft...
 802                  $caps[] = 'delete_posts';
 803              }
 804          } else {
 805              // The user is trying to edit someone else's post.
 806              $caps[] = 'delete_others_posts';
 807              // The post is published, extra cap required.
 808              if ( 'publish' == $post->post_status )
 809                  $caps[] = 'delete_published_posts';
 810              elseif ( 'private' == $post->post_status )
 811                  $caps[] = 'delete_private_posts';
 812          }
 813          break;
 814      case 'delete_page':
 815          $author_data = get_userdata( $user_id );
 816          //echo "post ID: {$args[0]}<br />";
 817          $page = get_page( $args[0] );
 818          $page_author_data = get_userdata( $page->post_author );
 819          //echo "current user id : $user_id, page author id: " . $page_author_data->ID . "<br />";
 820          // If the user is the author...
 821  
 822          if ('' != $page->post_author) {
 823              $page_author_data = get_userdata( $page->post_author );
 824          } else {
 825              //No author set yet so default to current user for cap checks
 826              $page_author_data = $author_data;
 827          }
 828  
 829          if ( $user_id == $page_author_data->ID ) {
 830              // If the page is published...
 831              if ( $page->post_status == 'publish' ) {
 832                  $caps[] = 'delete_published_pages';
 833              } elseif ( 'trash' == $page->post_status ) {
 834                  if ('publish' == get_post_meta($page->ID, '_wp_trash_meta_status', true) )
 835                      $caps[] = 'delete_published_pages';
 836              } else {
 837                  // If the page is draft...
 838                  $caps[] = 'delete_pages';
 839              }
 840          } else {
 841              // The user is trying to edit someone else's page.
 842              $caps[] = 'delete_others_pages';
 843              // The page is published, extra cap required.
 844              if ( $page->post_status == 'publish' )
 845                  $caps[] = 'delete_published_pages';
 846              elseif ( $page->post_status == 'private' )
 847                  $caps[] = 'delete_private_pages';
 848          }
 849          break;
 850          // edit_post breaks down to edit_posts, edit_published_posts, or
 851          // edit_others_posts
 852      case 'edit_post':
 853          $author_data = get_userdata( $user_id );
 854          //echo "post ID: {$args[0]}<br />";
 855          $post = get_post( $args[0] );
 856          if ( 'page' == $post->post_type ) {
 857              $args = array_merge( array( 'edit_page', $user_id ), $args );
 858              return call_user_func_array( 'map_meta_cap', $args );
 859          }
 860          $post_author_data = get_userdata( $post->post_author );
 861          //echo "current user id : $user_id, post author id: " . $post_author_data->ID . "<br />";
 862          // If the user is the author...
 863          if ( $user_id == $post_author_data->ID ) {
 864              // If the post is published...
 865              if ( 'publish' == $post->post_status ) {
 866                  $caps[] = 'edit_published_posts';
 867              } elseif ( 'trash' == $post->post_status ) {
 868                  if ('publish' == get_post_meta($post->ID, '_wp_trash_meta_status', true) )
 869                      $caps[] = 'edit_published_posts';
 870              } else {
 871                  // If the post is draft...
 872                  $caps[] = 'edit_posts';
 873              }
 874          } else {
 875              // The user is trying to edit someone else's post.
 876              $caps[] = 'edit_others_posts';
 877              // The post is published, extra cap required.
 878              if ( 'publish' == $post->post_status )
 879                  $caps[] = 'edit_published_posts';
 880              elseif ( 'private' == $post->post_status )
 881                  $caps[] = 'edit_private_posts';
 882          }
 883          break;
 884      case 'edit_page':
 885          $author_data = get_userdata( $user_id );
 886          //echo "post ID: {$args[0]}<br />";
 887          $page = get_page( $args[0] );
 888          $page_author_data = get_userdata( $page->post_author );
 889          //echo "current user id : $user_id, page author id: " . $page_author_data->ID . "<br />";
 890          // If the user is the author...
 891          if ( $user_id == $page_author_data->ID ) {
 892              // If the page is published...
 893              if ( 'publish' == $page->post_status ) {
 894                  $caps[] = 'edit_published_pages';
 895              } elseif ( 'trash' == $page->post_status ) {
 896                  if ('publish' == get_post_meta($page->ID, '_wp_trash_meta_status', true) )
 897                      $caps[] = 'edit_published_pages';
 898              } else {
 899                  // If the page is draft...
 900                  $caps[] = 'edit_pages';
 901              }
 902          } else {
 903              // The user is trying to edit someone else's page.
 904              $caps[] = 'edit_others_pages';
 905              // The page is published, extra cap required.
 906              if ( 'publish' == $page->post_status )
 907                  $caps[] = 'edit_published_pages';
 908              elseif ( 'private' == $page->post_status )
 909                  $caps[] = 'edit_private_pages';
 910          }
 911          break;
 912      case 'read_post':
 913          $post = get_post( $args[0] );
 914          if ( 'page' == $post->post_type ) {
 915              $args = array_merge( array( 'read_page', $user_id ), $args );
 916              return call_user_func_array( 'map_meta_cap', $args );
 917          }
 918  
 919          if ( 'private' != $post->post_status ) {
 920              $caps[] = 'read';
 921              break;
 922          }
 923  
 924          $author_data = get_userdata( $user_id );
 925          $post_author_data = get_userdata( $post->post_author );
 926          if ( $user_id == $post_author_data->ID )
 927              $caps[] = 'read';
 928          else
 929              $caps[] = 'read_private_posts';
 930          break;
 931      case 'read_page':
 932          $page = get_page( $args[0] );
 933  
 934          if ( 'private' != $page->post_status ) {
 935              $caps[] = 'read';
 936              break;
 937          }
 938  
 939          $author_data = get_userdata( $user_id );
 940          $page_author_data = get_userdata( $page->post_author );
 941          if ( $user_id == $page_author_data->ID )
 942              $caps[] = 'read';
 943          else
 944              $caps[] = 'read_private_pages';
 945          break;
 946      case 'unfiltered_upload':
 947          if ( defined('ALLOW_UNFILTERED_UPLOADS') && ALLOW_UNFILTERED_UPLOADS == true )
 948              $caps[] = $cap;
 949          else
 950              $caps[] = 'do_not_allow';
 951          break;
 952      default:
 953          // If no meta caps match, return the original cap.
 954          $caps[] = $cap;
 955      }
 956  
 957      return apply_filters('map_meta_cap', $caps, $cap, $user_id, $args);
 958  }
 959  
 960  /**
 961   * Whether current user has capability or role.
 962   *
 963   * @since 2.0.0
 964   *
 965   * @param string $capability Capability or role name.
 966   * @return bool
 967   */
 968  function current_user_can( $capability ) {
 969      $current_user = wp_get_current_user();
 970  
 971      if ( empty( $current_user ) )
 972          return false;
 973  
 974      $args = array_slice( func_get_args(), 1 );
 975      $args = array_merge( array( $capability ), $args );
 976  
 977      return call_user_func_array( array( &$current_user, 'has_cap' ), $args );
 978  }
 979  
 980  /**
 981   * Whether author of supplied post has capability or role.
 982   *
 983   * @since 2.9.0
 984   *
 985   * @param int|object $post Post ID or post object.
 986   * @param string $capability Capability or role name.
 987   * @return bool
 988   */
 989  function author_can( $post, $capability ) {
 990      if ( !$post = get_post($post) )
 991          return false;
 992  
 993      $author = new WP_User( $post->post_author );
 994  
 995      if ( empty( $author ) )
 996          return false;
 997  
 998      $args = array_slice( func_get_args(), 2 );
 999      $args = array_merge( array( $capability ), $args );
1000  
1001      return call_user_func_array( array( &$author, 'has_cap' ), $args );
1002  }
1003  
1004  /**
1005   * Retrieve role object.
1006   *
1007   * @see WP_Roles::get_role() Uses method to retrieve role object.
1008   * @since 2.0.0
1009   *
1010   * @param string $role Role name.
1011   * @return object
1012   */
1013  function get_role( $role ) {
1014      global $wp_roles;
1015  
1016      if ( ! isset( $wp_roles ) )
1017          $wp_roles = new WP_Roles();
1018  
1019      return $wp_roles->get_role( $role );
1020  }
1021  
1022  /**
1023   * Add role, if it does not exist.
1024   *
1025   * @see WP_Roles::add_role() Uses method to add role.
1026   * @since 2.0.0
1027   *
1028   * @param string $role Role name.
1029   * @param string $display_name Display name for role.
1030   * @param array $capabilities List of capabilities.
1031   * @return null|WP_Role WP_Role object if role is added, null if already exists.
1032   */
1033  function add_role( $role, $display_name, $capabilities = array() ) {
1034      global $wp_roles;
1035  
1036      if ( ! isset( $wp_roles ) )
1037          $wp_roles = new WP_Roles();
1038  
1039      return $wp_roles->add_role( $role, $display_name, $capabilities );
1040  }
1041  
1042  /**
1043   * Remove role, if it exists.
1044   *
1045   * @see WP_Roles::remove_role() Uses method to remove role.
1046   * @since 2.0.0
1047   *
1048   * @param string $role Role name.
1049   * @return null
1050   */
1051  function remove_role( $role ) {
1052      global $wp_roles;
1053  
1054      if ( ! isset( $wp_roles ) )
1055          $wp_roles = new WP_Roles();
1056  
1057      return $wp_roles->remove_role( $role );
1058  }
1059  
1060  ?>