wpdk-user.php

Go to the documentation of this file.

<?php

class WPDKUserMeta {

  const STATUS = '_wpdk_user_status';

  const STATUS_DESCRIPTION = '_wpdk_user_status_description';

  const COUNT_SUCCESS_LOGIN = '_wpdk_user_count_success_login';

  const COUNT_WRONG_LOGIN = '_wpdk_user_count_wrong_login';

  const LAST_TIME_SUCCESS_LOGIN = '_wpdk_user_last_time_success_login';

  const LAST_TIME_WRONG_LOGIN = '_wpdk_user_last_time_wrong_login';

  const LAST_TIME_LOGOUT = '_wpdk_user_last_time_logout';

  const REMOTE_ADDR = '_wpdk_user_remote_address';

  public static function update( $user_id, $post_data )
  {

    /* LAST_TIME_SUCCESS_LOGIN */
    $value = isset( $post_data[self::LAST_TIME_SUCCESS_LOGIN] ) ? $post_data[self::LAST_TIME_SUCCESS_LOGIN] : '';
    if ( !empty( $value ) ) {
      $value = strtotime( $value );
      update_user_meta( $user_id, self::LAST_TIME_SUCCESS_LOGIN, $value );
    }

    /* COUNT_SUCCESS_LOGIN */
    $value = isset( $post_data[self::COUNT_SUCCESS_LOGIN] ) ? $post_data[self::COUNT_SUCCESS_LOGIN] : '';
    update_user_meta( $user_id, self::COUNT_SUCCESS_LOGIN, $value );

    /* LAST_TIME_WRONG_LOGIN */
    $value = isset( $post_data[self::LAST_TIME_WRONG_LOGIN] ) ? $post_data[self::LAST_TIME_WRONG_LOGIN] : '';
    if ( !empty( $value ) ) {
      $value = strtotime( $value );
      update_user_meta( $user_id, self::LAST_TIME_WRONG_LOGIN, $value );
    }

    /* COUNT_WRONG_LOGIN */
    $value = isset( $post_data[self::COUNT_WRONG_LOGIN] ) ? $post_data[self::COUNT_WRONG_LOGIN] : '';
    update_user_meta( $user_id, self::COUNT_WRONG_LOGIN, $value );

    /* LAST_TIME_LOGOUT */
    $value = isset( $post_data[self::LAST_TIME_LOGOUT] ) ? $post_data[self::LAST_TIME_LOGOUT] : '';
    if ( !empty( $value ) ) {
      $value = strtotime( $value );
      update_user_meta( $user_id, self::LAST_TIME_LOGOUT, $value );
    }

    /* STATUS */
    $value = isset( $post_data[self::STATUS] ) ? $post_data[self::STATUS] : '';
    update_user_meta( $user_id, self::STATUS, $value );

    /* STATUS_DESCRIPTION */
    $value = isset( $post_data[self::STATUS_DESCRIPTION] ) ? $post_data[self::STATUS_DESCRIPTION] : '';
    update_user_meta( $user_id, self::STATUS_DESCRIPTION, $value );

  }

}


class WPDKUserStatus {

  const DISABLED = 'disabled';

  public static function statuses()
  {
    $statuses = array(
      ''             => __( 'Not set' ),
      self::DISABLED => __( 'Disabled' ),
    );
    return apply_filters( 'wpdk_user_status_statuses', $statuses );
  }
}


class WPDKUser extends WP_User {

  public $first_name;

  public $last_name;

  public $nice_name;

  public $full_name;

  public $display_name;

  public $email;

  public $status;

  public $statusDescription;

  public static function current_user()
  {
    // Check for user logged in
    if( !is_user_logged_in() ) {
      return null;
    }
    return new self;
  }

  public function __construct( $user = 0, $name = '', $blog_id = '' )
  {

    $id_user = 0;

    // Sanitize $id
    if ( is_numeric( $user ) ) {
      $id_user = $user;

      // If zero get the current id user
      if ( empty( $id_user ) ) {
        $id_user = get_current_user_id();
      }
    }
    elseif ( is_object( $user ) && isset( $user->ID ) ) {
      $id_user = absint( $user->ID );
    }
    elseif ( is_array( $user ) && isset( $user['ID'] ) ) {
      $id_user = absint( $user['ID'] );
    }

    // Get by email
    elseif ( is_string( $user ) && is_email( $user ) ) {
      $user    = get_user_by( 'email', $user );
      $id_user = $user->ID;
    }

    parent::__construct( $id_user, $name, $blog_id );

    // Set the extended property when an user is set
    if ( !empty( $id_user ) ) {
      $this->first_name        = $this->get( 'first_name' );
      $this->last_name         = $this->get( 'last_name' );
      $this->nice_name         = $this->data->user_nicename;
      $this->full_name         = $this->full_name( $this->first_name, $this->last_name );
      $this->display_name      = $this->data->display_name;
      $this->email             = sanitize_email( $this->data->user_email );
      $this->status            = $this->get( WPDKUserMeta::STATUS );
      $this->statusDescription = $this->get( WPDKUserMeta::STATUS_DESCRIPTION );

      // Sanitize string->int
      $this->data->ID = absint( $id_user );
    }
  }

  public static function nice_name( $firstName, $lastName )
  {
    $result = sprintf( '%s.%s', strtoupper( substr( $firstName, 0, 1 ) ), ucfirst( $lastName ) );
    return $result;
  }

  public static function full_name( $firstName, $lastName, $nameFirst = true )
  {
    if ( $nameFirst ) {
      $result = sprintf( '%s %s', $firstName, $lastName );
    }
    else {
      $result = sprintf( '%s %s', $lastName, $firstName );
    }
    return $result;
  }

  public function create( $first_name, $last_name, $email, $password = false, $enabled = false, $role = 'subscriber' )
  {
    return WPDKUsers::init()->create( $first_name, $last_name, $email, $password, $enabled, $role );
  }

  // -------------------------------------------------------------------------------------------------------------------
  // User transient
  // -------------------------------------------------------------------------------------------------------------------

  public static function getTransientWithUser( $transient, $user_id = null )
  {
    $user_id = is_null( $user_id ) ? get_current_user_id() : $user_id;

    $pre = apply_filters( 'pre_user_transient_' . $transient, false, $user_id );
    if ( false !== $pre ) {
      return $pre;
    }

    $transient_timeout = '_transient_timeout_' . $transient;
    $transient         = '_transient_' . $transient;
    if ( get_user_meta( $user_id, $transient_timeout, true ) < time() ) {
      delete_user_meta( $user_id, $transient );
      delete_user_meta( $user_id, $transient_timeout );
      return false;
    }

    $value = get_user_meta( $user_id, $transient, true );

    return apply_filters( 'user_transient_' . $transient, $value, $user_id );
  }

  public function getTransient( $transient )
  {
    if( !empty( $this->ID ) ) {
      return self::getTransientWithUser( $transient, $this->ID );
    }
  }

  public static function getTransientTimeWithUser( $transient, $user_id = null )
  {
    $user_id           = is_null( $user_id ) ? get_current_user_id() : $user_id;
    $transient_timeout = '_transient_timeout_' . $transient;
    return get_user_meta( $user_id, $transient_timeout, true );
  }

  public function getTransientTime( $transient )
  {
    if ( !empty( $this->ID ) ) {
      return self::getTransientTimeWithUser( $transient, $this->ID );
    }
  }


  public static function setTransientWithUser( $transient, $value, $expiration = 0, $user_id = null )
  {
    $user_id = is_null( $user_id ) ? get_current_user_id() : $user_id;

    $value = apply_filters( 'pre_set_user_transient_' . $transient, $value, $user_id );

    $transient_timeout = '_transient_timeout_' . $transient;
    $transient         = '_transient_' . $transient;
    if ( false === get_user_meta( $user_id, $transient, true ) ) {
      if ( $expiration ) {
        update_user_meta( $user_id, $transient_timeout, time() + $expiration );
      }
      $result = update_user_meta( $user_id, $transient, $value );
    }
    else {
      if ( $expiration ) {
        update_user_meta( $user_id, $transient_timeout, time() + $expiration );
      }
      $result = update_user_meta( $user_id, $transient, $value );
    }

    if ( $result ) {
      do_action( 'set_user_transient_' . $transient );
      do_action( 'setted_user_transient', $transient, $user_id );
    }
    return $result;
  }

  public function setTransient( $transient, $value, $expiration = 0 )
  {
    if ( !empty( $this->ID ) ) {
      self::setTransientWithUser( $transient, $value, $expiration, $this->ID );
    }
  }


  // -------------------------------------------------------------------------------------------------------------------
  // User info
  // -------------------------------------------------------------------------------------------------------------------

  public function gravatar( $size = 40, $alt = '', $default = "wavatar" )
  {
    return WPDKUsers::init()->gravatar( $this->ID, $size, $alt, $default );
  }

  public function avatar( $size = 40 )
  {
    return WPDKUsers::init()->avatar( $this->ID, $size );
  }



  public function age( $birthday )
  {
    $year_diff = 0;

    if ( !empty( $birthday ) ) {
      if ( false !== strpos( $birthday, '-' ) ) {
        list( $year, $month, $day ) = explode( '-', $birthday );
      }
      else {
        list( $day, $month, $year ) = explode( '/', $birthday );
      }
      $year_diff  = date( 'Y' ) - $year;
      $month_diff = date( 'm' ) - $month;
      $day_diff   = date( 'd' ) - $day;
      if ( $month_diff < 0 || ( $month_diff == 0 && $day_diff < 0 ) ) {
        $year_diff--;
      }
    }
    return intval( $year_diff );
  }

  // -------------------------------------------------------------------------------------------------------------------
  // Roles
  // -------------------------------------------------------------------------------------------------------------------

  public function hasRoles( $roles )
  {
    global $wp_roles;

    if ( !isset( $wp_roles ) ) {
      $wp_roles = new WP_Roles();
    }

    $current_roles = $this->roles;
    if ( is_array( $roles ) ) {
      foreach ( $roles as $role ) {
        if ( in_array( $role, $current_roles ) ) {
          return true;
        }
      }
      return false;
    }
    else {
      return in_array( $roles, $current_roles );
    }
  }

  public static function roleNameForUserID( $id_user )
  {
    global $wp_roles;

    $id_user = absint( $id_user );
    $user    = new WP_User( $id_user );
    if ( !empty( $user ) ) {
      $role_key = $user->roles[key( $user->roles )];
      if ( !empty( $role_key ) ) {
        return $wp_roles->roles[$role_key]['name'];
      }
    }
    return false;
  }

  public static function hasCap( $cap, $id_user = null )
  {
    if ( is_null( $id_user ) ) {
      $id_user = get_current_user_id();
    }
    $user = new WP_User( $id_user );
    if ( $user ) {
      return $user->has_cap( $cap );
    }
    return false;
  }

  public function hasCaps( $caps )
  {

    $all_caps = $this->allcaps;
    if ( is_array( $caps ) ) {
      foreach ( $caps as $cap ) {
        if ( isset( $all_caps[$cap] ) ) {
          return true;
        }
      }
    }
    else {
      return in_array( $all_caps, $caps );
    }
    return false;
  }

  public static function allCapabilities()
  {
    global $wp_roles;
    $merge = array();

    $roles = $wp_roles->get_names();
    foreach ( $roles as $key => $rolename ) {
      $role  = get_role( $key );
      $merge = array_merge( $merge, $role->capabilities );
    }
    $result = array_keys( $merge );
    sort( $result );
    $result = array_combine( $result, $result );
    return $result;
  }

  public static function updateUserCapabilities( $id_user, $selected_caps, $capabilities )
  {
    if ( $id_user && is_array( $selected_caps ) ) {
      $user = new WP_User( $id_user );
      foreach ( $capabilities as $key => $cap ) {
        if ( in_array( $key, $selected_caps ) ) {
          /* Add */
          $user->add_cap( $key );
        }
        else {
          /* Del */
          $user->remove_cap( $key );
        }
      }
    }
  }

}


class WPDKUsers {

  public static function init()
  {
    static $instance = null;
    if ( is_null( $instance ) ) {
      $instance = new WPDKUsers();
    }
    return $instance;
  }

  private function __construct()
  {

    /* Do a several action/filter to monitoring user action. */

    //$this->logout();
    add_action( 'init', array( $this, 'logout' ) );

    /* Main hook for common check in front end. */
    //add_action( 'wp_head', array( $this, 'wp_head_signin' ) );
    //add_action( 'wp_head', array( $this, 'wp_head_signout' ) );

    /* Hook on Login. */
    add_action( 'wp_login', array( $this, 'wp_login' ) );
    add_action( 'wp_logout', array( $this, 'wp_logout' ) );
    add_action( 'wp_login_failed', array( $this, 'wp_login_failed' ) );

    /* includes/wp_insert_user() Nuovo Utente registrato  */
    //add_action( 'user_register', array( $this, 'user_register' ) );

    /* includes/wp_insert_user() Utente già registrato quindi aggiornamento dati */
    add_action( 'delete_user', array( $this, 'delete_user' ) );
    add_action( 'deleted_user', array( $this, 'deleted_user' ) );

    /* Backend user profile (own) */
    add_action( 'show_user_profile', array( $this, 'show_user_profile' ) );
    add_action( 'personal_options_update', array( $this, 'personal_options_update' ) );
    add_action( 'personal_options', array( $this, 'personal_options' ) );
    add_action( 'profile_personal_options', array( $this, 'profile_personal_options' ) );

    /* Backend user profile (other) */
    add_action( 'edit_user_profile', array( $this, 'edit_user_profile' ) );
    add_action( 'edit_user_profile_update', array( $this, 'edit_user_profile_update' ) );

    /* Extends User edit profile */

    /* Disable and locking featured */
    add_filter( 'wp_authenticate_user', array( $this, 'wp_authenticate_user' ), 1 );

    add_filter( 'user_contactmethods', array( $this, 'user_contactmethods' ) );
  }

  public function logout()
  {
    /* If a user is logged in. */
    if ( is_user_logged_in() ) {
      $user_id = get_current_user_id();
      $status  = get_user_meta( $user_id, WPDKUserMeta::STATUS, true );
      $logout  = false;

      /* Logout for disabled User. */
      if ( !empty( $status ) && WPDKUserStatus::DISABLED == $status ) {
        $logout = true;
      }

      /* Manual logout. */
      if ( isset( $_REQUEST['wpdk_logout'] ) ) {
        $logout = true;
      }

      if ( true === $logout ) {
        /* Log off the user. */
        wp_logout();
        if ( is_admin() ) {
          wp_safe_redirect( wp_login_url( wp_get_referer() ) );
        }
        else {
          wp_safe_redirect( stripslashes( $_SERVER['REQUEST_URI'] ) );
        }
        exit;
      }
    }
  }


  // -----------------------------------------------------------------------------------------------------------------
  // Signin actions and filters
  // -----------------------------------------------------------------------------------------------------------------

  public function wp_authenticate_user( $user )
  {
    if ( is_wp_error( $user ) ) {
      return $user;
    }

    /* Get the user status. */
    $status = $user->get( WPDKUserMeta::STATUS );

    if ( WPDKUserStatus::DISABLED == $status ) {
      /* Ask for continue. */
      $continue = apply_filters( 'wpdk_users_should_denied_signin', true, $user->ID, $status );
      if ( $continue ) {
        $message = $user->get( WPDKUserMeta::STATUS_DESCRIPTION );
        $message = apply_filters( 'wpdk_users_access_denied_status_description', $message, $user->ID, $status );
        return new WP_Error( 'wpdk_users_access_denied', $message, array(
          $user,
          $status
        ) );
      }
    }

    return $user;
  }

  public function wp_login( $user_login, $user = null )
  {

    /* Get user by login. */
    if ( is_null( $user ) ) {
      $user = get_user_by( 'login', $user_login );
    }

    /* Get success login count. */
    $count = absint( $user->get( WPDKUserMeta::COUNT_SUCCESS_LOGIN ) );
    if ( empty( $count ) ) {
      $count = 0;
    }
    update_user_meta( $user->ID, WPDKUserMeta::COUNT_SUCCESS_LOGIN, $count + 1 );
    update_user_meta( $user->ID, WPDKUserMeta::COUNT_WRONG_LOGIN, 0 );
    update_user_meta( $user->ID, WPDKUserMeta::LAST_TIME_SUCCESS_LOGIN, time() );
  }

  public function wp_login_failed( $user_login )
  {

    if ( empty( $user_login ) ) {
      return false;
    }

    $user = get_user_by( 'login', $user_login );

    /* Check if the user exists. */
    if ( false === $user ) {
      return false;
    }

    $count = absint( $user->get( WPDKUserMeta::COUNT_WRONG_LOGIN ) );
    if ( empty( $count ) ) {
      $count = 0;
    }
    $count++;

    /* Update the wrong login count. */
    update_user_meta( $user->ID, WPDKUserMeta::COUNT_WRONG_LOGIN, $count );

    /* Notified the wrong user login count. */
    do_action( 'wpdk_user_wrong_login_count', $user->ID, $count );

    return true;

  }

  // -------------------------------------------------------------------------------------------------------------------
  // Signin utility
  // -------------------------------------------------------------------------------------------------------------------

  public function signIn( $user, $password, $remember = false )
  {

    $user_id = false;
    $email   = '';

    /* Check user id */
    if ( is_numeric( $user ) ) {
      $user_id = $user;
    }
    /* Check for email */
    elseif ( is_email( $user ) ) {
      /* Sanitize email */
      $email = sanitize_email( $user );
      /* User exists with email */
      $user_id = email_exists( $email );
    }
    /* Check for user login */
    else {
      $user = get_user_by( 'login', $user );
      if ( $user ) {
        $user_id = $user->ID;
      }
    }

    if ( false !== $user_id ) {
      $user = new WPDKUser( $user_id );
      if ( $user->exists() && WPDKUserStatus::DISABLED !== $user->status ) {
        $result = wp_authenticate( $user->user_login, $password );
        if ( !is_wp_error( $result ) ) {
          /* Set remember cookie */
          wp_set_auth_cookie( $user->ID, $remember );
          do_action( 'wp_login', $user->user_login, $user );

          /* Internal counter */
          $this->wp_login( $user->user_login, $user );

          /* Authenticate! You are */
          wp_set_current_user( $user->ID );
          return true;
        }
      }
    }

    do_action( 'wpdk_singin_wrong', empty( $email ) ? $user_id : $email, $password );

    return false;
  }

  public function authenticate( $email, $password )
  {
    if ( empty( $email ) || empty( $password ) ) {
      return false;
    }

    $id_user = email_exists( $email );
    if ( !empty( $id_user ) ) {
      $user   = new WPDKUser( $id_user );
      $access = wp_authenticate( $user->data->user_login, $password );
      if ( !is_wp_error( $access ) ) {
        return $id_user;
      }
    }
    return false;
  }

  // -----------------------------------------------------------------------------------------------------------------
  // Signout actions and filters
  // -----------------------------------------------------------------------------------------------------------------

  public function wp_logout()
  {
    $user_id = get_current_user_id();
    if ( !empty( $user_id ) ) {
      update_user_meta( $user_id, WPDKUserMeta::LAST_TIME_LOGOUT, time() );
    }
  }

  // -----------------------------------------------------------------------------------------------------------------
  // Signout utility
  // -----------------------------------------------------------------------------------------------------------------

  public function signout()
  {

    /* Esegue il logout da WordPress. */
    wp_logout();

    /* Per default ridirezione sulla home page del sito. */
    $blog_url = get_bloginfo( 'url' );
    wp_safe_redirect( $blog_url );
    exit();
  }

  // ----------------------------------------------------------------------------------------------------------------
  // Create utility
  // -----------------------------------------------------------------------------------------------------------------

  public function create( $first_name, $last_name, $email, $password = false, $enabled = false, $role = 'subscriber' )
  {

    /* For security reason an user must have a password. */
    if ( false === $password ) {
      $password = WPDKCrypt::randomAlphaNumber();
      /* @todo Notify to user the password. */
      do_action( 'wpdk_users_random_password', $password );
    }

    $nice_name    = WPDKUser::nice_name( $first_name, $last_name );
    $display_name = WPDKUser::full_name( $first_name, $last_name );

    $user_data = array(
      'user_login'    => $email,
      'user_pass'     => $password,
      'user_email'    => $email,
      'user_nicename' => $nice_name,
      'nickname'      => $nice_name,
      'display_name'  => $display_name,
      'first_name'    => $first_name,
      'last_name'     => $last_name,
      'role'          => $role
    );

    $user_id = wp_insert_user( $user_data );

    if ( is_wp_error( $user_id ) ) {
      return $user_id;
    }

    /* Store IP Address */
    if ( isset( $_SERVER['REMOTE_ADDR'] ) && !empty( $_SERVER['REMOTE_ADDR'] ) ) {
      update_user_meta( $user_id, WPDKUserMeta::REMOTE_ADDR, $_SERVER['REMOTE_ADDR'] );
    }

    /* Disable user if required */
    if ( false === $enabled ) {
      $status = apply_filters( 'wpdk_users_status', WPDKUserStatus::DISABLED, $user_id );
      update_user_meta( $user_id, WPDKUserMeta::STATUS, $status );

      $status_description = apply_filters( 'wpdk_users_status_description', '', $user_id );
      update_user_meta( $user_id, WPDKUserMeta::STATUS_DESCRIPTION, $status_description );
    }

    return $user_id;
  }


  // -----------------------------------------------------------------------------------------------------------------
  // User profile (own)
  // -----------------------------------------------------------------------------------------------------------------

  public function show_user_profile( $user )
  {

    echo '<br clear="all" /><a name="wpdk"></a>';

    $message                  = __( 'This view <strong>is enhanced</strong> by wpXtreme and WPDK framework. Please, have a look below for additional information.', WPDK_TEXTDOMAIN );
    $alert                    = new WPDKTwitterBootstrapAlert( 'wpdk-alert-show_user_profile', $message, WPDKTwitterBootstrapAlertType::INFORMATION );
    $alert->permanent_dismiss = true;
    $alert->display();

    /* Only the administrator can edit this extra information */
    $disabled = !current_user_can( 'manage_options' );

    /* Sanitize values */
    $last_time_success_login = $user->get( WPDKUserMeta::LAST_TIME_SUCCESS_LOGIN );
    $last_time_wrong_login   = $user->get( WPDKUserMeta::LAST_TIME_WRONG_LOGIN );
    $last_time_logout        = $user->get( WPDKUserMeta::LAST_TIME_LOGOUT );
    $status_description      = $user->get( WPDKUserMeta::STATUS_DESCRIPTION );

    $fields = array(
      __( 'Login information', WPDK_TEXTDOMAIN )  => array(
        array(
          array(
            'type'     => WPDKUIControlType::DATETIME,
            'name'     => WPDKUserMeta::LAST_TIME_SUCCESS_LOGIN,
            'label'    => __( 'Last success login', WPDK_TEXTDOMAIN ),
            'value'    => empty( $last_time_success_login ) ? '' : date( __( 'm/d/Y H:i', WPDK_TEXTDOMAIN ), $last_time_success_login ),
            'disabled' => $disabled
          ),
          array(
            'type'     => WPDKUIControlType::NUMBER,
            'name'     => WPDKUserMeta::COUNT_SUCCESS_LOGIN,
            'label'    => __( '# success login', WPDK_TEXTDOMAIN ),
            'value'    => $user->get( WPDKUserMeta::COUNT_SUCCESS_LOGIN ),
            'disabled' => true
          ),
        ),
        array(
          array(
            'type'     => WPDKUIControlType::DATETIME,
            'name'     => WPDKUserMeta::LAST_TIME_WRONG_LOGIN,
            'label'    => __( 'Last wrong login', WPDK_TEXTDOMAIN ),
            'value'    => empty( $last_time_wrong_login ) ? '' : date( __( 'm/d/Y H:i', WPDK_TEXTDOMAIN ), $last_time_wrong_login ),
            'disabled' => $disabled
          ),
          array(
            'type'     => WPDKUIControlType::NUMBER,
            'name'     => WPDKUserMeta::COUNT_WRONG_LOGIN,
            'label'    => __( '# wrong login', WPDK_TEXTDOMAIN ),
            'value'    => $user->get( WPDKUserMeta::COUNT_WRONG_LOGIN ),
            'disabled' => $disabled
          ),
        ),
      ),

      __( 'Logout information', WPDK_TEXTDOMAIN ) => array(
        array(
          array(
            'type'     => WPDKUIControlType::DATETIME,
            'name'     => WPDKUserMeta::LAST_TIME_LOGOUT,
            'label'    => __( 'Last logout', WPDK_TEXTDOMAIN ),
            'value'    => empty( $last_time_logout ) ? '' : date( __( 'm/d/Y H:i', WPDK_TEXTDOMAIN ), $last_time_logout ),
            'disabled' => $disabled
          ),
        ),
      ),

      __( 'Status', WPDK_TEXTDOMAIN )             => array(
        array(
          array(
            'type'     => WPDKUIControlType::SELECT,
            'name'     => WPDKUserMeta::STATUS,
            'label'    => __( 'Status', WPDK_TEXTDOMAIN ),
            'value'    => $user->get( WPDKUserMeta::STATUS ),
            'options'  => WPDKUserStatus::statuses(),
            'disabled' => $disabled
          ),
        ),
        array(
          array(
            'type'        => WPDKUIControlType::TEXTAREA,
            'name'        => WPDKUserMeta::STATUS_DESCRIPTION,
            'rows'        => 3,
            'cols'        => 40,
            'label'       => __( 'Description', WPDK_TEXTDOMAIN ),
            'placeholder' => __( 'eg: this user is disabled because...', WPDK_TEXTDOMAIN ),
            'value'       => $status_description,
            'disabled'    => $disabled,
          )
        ),
      ),
    );

    $fields = apply_filters( 'wpdk_users_fields_profile', $fields, $user );

    $layout = new WPDKUIControlsLayout( $fields );
    $layout->display();

    do_action( 'wpdk_users_show_user_profile', $user );
  }

  public function personal_options_update( $id_user )
  {
    /* Same for other users, see below */
    $this->edit_user_profile_update( $id_user );
  }

  public function personal_options( $user )
  {
    $message = __( 'This view <strong>is enhanced</strong> by wpXtreme and WPDK framework. Please, <strong><a href="#wpdk">have a look below</a></strong> for additional information.', WPDK_TEXTDOMAIN );
    $alert   = new WPDKTwitterBootstrapAlert( 'wpdk-alert-personal_options', $message, WPDKTwitterBootstrapAlertType::INFORMATION );
    $alert->permanent_dismiss = true;
    $alert->display();
  }

  public function profile_personal_options( $user )
  {
    /* Nothing to do... for now */
  }

  // -----------------------------------------------------------------------------------------------------------------
  // User profile (other)
  // -----------------------------------------------------------------------------------------------------------------

  public function edit_user_profile( $user )
  {
    /* At this moment display the same informations */
    $this->show_user_profile( $user );
  }

  public function edit_user_profile_update( $id_user )
  {
    if ( !current_user_can( 'edit_user' ) ) {
      return false;
    }

    /* Update the WPDK extra information */
    if ( current_user_can( 'manage_options' ) ) {
      WPDKUserMeta::update( $id_user, $_POST );
    }
    return true;
  }


  public function delete_user( $id_user )
  {
    /* @todo Do implement */
  }

  public function deleted_user( $id_user )
  {
    /* @todo Do implement */
  }

  public function user_contactmethods( $contacts )
  {
    return $contacts;
  }


  public static function userWithMetaAndValue( $meta_key, $meta_value )
  {
    global $wpdb;

    $sql    = <<< SQL
SELECT user_id
FROM {$wpdb->usermeta}
WHERE meta_key = '{$meta_key}'
AND meta_value = '{$meta_value}'
SQL;
    $result = $wpdb->get_var( $sql );

    return $result;
  }

  public static function usersWithCaps( $find_caps )
  {
    $users_caps = WPDKCapabilities::getInstance()->usersCapability();

    $users = array();
    foreach ( $users_caps as $user_id => $caps ) {
      $keys = array_keys( $caps );
      if ( in_array( $find_caps, $keys ) ) {
        $users[] = $user_id;
      }
    }
    return $users;
  }

  // -------------------------------------------------------------------------------------------------------------------
  // User info
  // -------------------------------------------------------------------------------------------------------------------

  public function gravatar( $id_user = null, $size = 40, $alt = '', $default = 'wavatar' )
  {
    if ( is_null( $id_user ) ) {
      $id_user = 0;
    }
    $user = new WPDKUser( $id_user );
    if ( $user ) {
      $alt  = empty( $alt ) ? $user->display_name : $alt;

      // Use SSL
      $gravatar = is_ssl() ? 'https://secure.gravatar.com/avatar/' : 'http://0.gravatar.com/avatar/';

      $src  = sprintf( '%s%s?s=%s&d=%s', $gravatar, md5( $user->email ), $size, $default );
      $html = sprintf( '<img src="%s" alt="%s" title="%s" />', $src, $alt, $alt );

      return $html;
    }
    return false;
  }

  public function avatar( $id_user = null, $size = 40 )
  {
    if ( is_null( $id_user ) ) {
      $id_user = 0;
    }
    $user = new WPDKUser( $id_user );
    if ( $user ) {
      $alt = empty( $alt ) ? $user->display_name : $alt;

      $default = apply_filters( 'wpdk_default_avatar', 'wavatar' );

      // Use SSL
      $gravatar = is_ssl() ? 'https://secure.gravatar.com/avatar/' : 'http://0.gravatar.com/avatar/';

      $src = sprintf( '%s%s?s=%s&d=%s', $gravatar, md5( $user->email ), $size, $default );
      $img = new WPDKHTMLTagImg( $src, $alt, $size, $size );
      return $img;
    }
    return false;
  }



  // -----------------------------------------------------------------------------------------------------------------
  // Users list
  // -----------------------------------------------------------------------------------------------------------------

  public function arrayUserForSDF()
  {
    $users      = array();
    $users_list = get_users();
    if ( $users_list ) {
      foreach ( $users_list as $user ) {
        $user_id         = '' . $user->ID;
        $users[$user_id] = sprintf( '%s (%s)', $user->display_name, $user->user_email );
      }
    }
    return $users;
  }


  // -----------------------------------------------------------------------------------------------------------------
  // DEPRECATED
  // -----------------------------------------------------------------------------------------------------------------

  public static function arrayRoles()
  {
    global $wp_roles;

    if ( !isset( $wp_roles ) ) {
      $wp_roles = new WP_Roles();
    }

    $result = array();

    $roles = $wp_roles->get_names();
    foreach ( $roles as $key => $role ) {
      $result[$key] = $role;
    }
    return $result;
  }
}


class WPDKRole extends WP_Role {

  public $displayName;

  public $description;

  public $owner;


  public function __construct( $role, $display_name = '', $capabilities = array(), $description = '', $owner = '' )
  {

    /* Sanitize the role name. */
    $role_id = sanitize_title( strtolower( $role ) );

    /* Get Roles */
    $wpdk_roles  = WPDKRoles::getInstance();
    $role_object = $wpdk_roles->get_role( $role_id );

    /* If role not exists then create it. */
    if ( is_null( $role_object ) ) {
      /* If display name is empty and doesn't exists, then the display name is the role name-id */
      if ( empty( $display_name ) ) {
        $display_name = ucfirst( $role );
      }
      $role_object        = $wpdk_roles->add_role( $role_id, $display_name, $capabilities, $description, $owner );
      $this->displayName  = $display_name;
      $this->capabilities = $role_object->capabilities;
      $this->name         = $role_id;

      /* Extends */
      $this->description = $description;
      $this->owner       = $owner;
    }
    else {
      $this->name         = $role;
      $this->displayName  = $wpdk_roles->role_names[$role_id];
      $this->capabilities = $role_object->capabilities;

      /* Extends */
      $extra = get_option( WPDKRoles::OPTION_KEY );

      if ( !empty( $extra ) && isset( $extra[$role_id] ) ) {
        $this->description = $extra[$role][1];
        $this->owner       = $extra[$role][2];
      }
    }
  }

  public function update()
  {
    $extra = get_option( WPDKRoles::OPTION_KEY );
    if ( !empty( $extra ) ) {
      $extra[$this->name] = array(
        $this->displayName,
        $this->description,
        $this->owner
      );
    }
    else {
      $extra = WPDKRoles::init()->activeRoles;
    }
    return update_option( WPDKRoles::OPTION_KEY, $extra );
  }

}


class WPDKRoles extends WP_Roles {

  const OPTION_KEY = '_wpdk_roles_extends';

  // since 1.4.16 - WordPress has six pre-defined roles:
  const SUPER_ADMIN   = 'super-admin';
  const ADMINISTRATOR = 'administrator';
  const EDITOR        = 'editor';
  const AUTHOR        = 'author';
  const CONTRIBUTOR   = 'contributor';
  const SUBSCRIBER    = 'subscriber';

  public $activeRoles;

  public $inactiveRoles;

  public $wordPressRoles;

  public $count;

  public $arrayCountUsersByRole;

  public $arrayCapabilitiesByRole;

  private $_extendedData;

  private static $instance = null;

  public static function init()
  {
    return self::getInstance();
  }

  public static function getInstance()
  {
    if ( is_null( self::$instance ) ) {
      self::$instance = new WPDKRoles();
    }
    return self::$instance;
  }

  public static function invalidate()
  {
    self::$instance = null;
    return self::getInstance();
  }


  public function __construct()
  {
    parent::__construct();

    /* Get the extended data. */
    $this->_extendedData = get_option( self::OPTION_KEY );

    if ( !empty( $this->role_names ) ) {
      $this->count = count( $this->role_names );
    }

    /* Init properties. */
    $this->wordPressRoles();
    $this->activeRoles();
    $this->inactiveRoles();
    $this->countUsersByRole();

    /* Create An key value pairs array with key = role and value = list of capabilities. */
    $this->arrayCapabilitiesByRole();

    if ( empty( $this->_extendedData ) ) {
      $this->_extendedData = array_merge( $this->activeRoles, $this->inactiveRoles, $this->wordPressRoles );
      update_option( self::OPTION_KEY, $this->_extendedData );
    }

  }

  // -----------------------------------------------------------------------------------------------------------------
  // Information
  // -----------------------------------------------------------------------------------------------------------------

  public function activeRoles()
  {

    /* Calculate only if the property if note set. */
    if ( !isset( $this->activeRoles ) ) {

      $this->activeRoles = array();
      foreach ( $this->role_names as $role => $name ) {
        $count = $this->countUsersByRole( $role );
        if ( !empty( $count ) ) {
          $this->activeRoles[$role] = isset( $this->_extendedData[$role] ) ? $this->_extendedData[$role] : array( $name, '', '' );
        }
      }
    }
    $this->activeRoles = apply_filters( 'wpdk_roles_active', $this->activeRoles );
    return $this->activeRoles;
  }

  public function inactiveRoles()
  {

    /* Calculate only if the property if note set. */
    if ( !isset( $this->inactiveRoles ) ) {

      $this->inactiveRoles = array();
      foreach ( $this->role_names as $role => $name ) {
        $count = $this->countUsersByRole( $role );
        if ( empty( $count ) ) {
          $this->inactiveRoles[$role] = isset( $this->_extendedData[$role] ) ? $this->_extendedData[$role] : array( $name, '', '' );
        }
      }
    }

    $this->inactiveRoles = apply_filters( 'wpdk_roles_inactive', $this->inactiveRoles );
    return $this->inactiveRoles;
  }

  public function countUsersByRole( $user_role = '' )
  {

    /* If the count is not already set for all roles, let's get it. */
    if ( !isset( $this->arrayCountUsersByRole ) ) {

      $this->arrayCountUsersByRole = array();

      /*
       * Count users
       *
       * array(2) {
       *   ["total_users"]=> int(9)
       *   ["avail_roles"]=> array(4) {
       *     ["administrator"]=> int(6)
       *     ["author"]=> int(1)
       *     ["contributor"]=> int(1)
       *     ["subscriber"]=> int(1)
       *   }
       * }
       */
      $user_count = count_users();

      /* Loop through the user count by role to get a count of the users with each role. */
      foreach ( $user_count['avail_roles'] as $role => $count ) {
        $this->arrayCountUsersByRole[$role] = $count;
      }
    }

    /* If the $user_role parameter wasn't passed into this function, return the array of user counts. */
    if ( empty( $user_role ) ) {
      return $this->arrayCountUsersByRole;
    }

    /* If the role has no users, we need to set it to '0'. */
    if ( !isset( $this->arrayCountUsersByRole[$user_role] ) ) {
      $this->arrayCountUsersByRole[$user_role] = 0;
    }

    /* Return the user count for the given role. */
    return $this->arrayCountUsersByRole[$user_role];
  }

  public function arrayCapabilitiesByRole()
  {

    /* If the count is not already set for all roles, let's get it. */
    if ( !isset( $this->arrayCapabilitiesByRole ) ) {

      foreach ( $this->get_names() as $role => $name ) {

        /* Count capabilities for role too. */
        $wp_role = $this->get_role( $role );
        ksort( $wp_role->capabilities );
        $this->arrayCapabilitiesByRole[$role] = $wp_role->capabilities;
      }
    }
    return $this->arrayCapabilitiesByRole;
  }

  public function roleExists( $role )
  {
    return ( array_key_exists( $role, $this->role_names ) );
  }

  public function wordPressRoles()
  {
    $this->wordPressRoles = array(
      'administrator' => array( 'Administrator', __( 'Somebody who has access to all the administration features', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'editor'        => array( 'Editor', __( 'Somebody who can publish and manage posts and pages as well as manage other users posts, etc.', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'author'        => array( 'Author', __( 'Somebody who can publish and manage their own posts', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'contributor'   => array( 'Contributor', __( 'Somebody who can write and manage their posts but not publish them', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'subscriber'    => array( 'Subscriber', __( 'Somebody who can only manage their profile', WPDK_TEXTDOMAIN ), 'WordPress' ),
    );

    $this->wordPressRoles = apply_filters( 'wpdk_roles_defaults', $this->wordPressRoles );
    return $this->wordPressRoles;
  }

  // -----------------------------------------------------------------------------------------------------------------
  // Override
  // -----------------------------------------------------------------------------------------------------------------

  public function add_role( $role, $display_name, $capabilities = array(), $description = '', $owner = '' )
  {
    /* Normalize caps */
    $caps = array();
    foreach ( $capabilities as $cap ) {
      $caps[$cap] = true;
    }

    $role_object = parent::add_role( $role, $display_name, $caps );
    if ( !is_null( $role_object ) ) {
      if ( !isset( $this->_extendedData[$role] ) ) {
        $this->_extendedData[$role] = array(
          $display_name,
          $description,
          $owner
        );
      }
      update_option( self::OPTION_KEY, $this->_extendedData );
    }
    return $role_object;
  }

  public function remove_role( $role )
  {
    parent::remove_role( $role );
    unset( $this->_extendedData[$role] );
    update_option( self::OPTION_KEY, $this->_extendedData );
  }


  // -----------------------------------------------------------------------------------------------------------------
  // UI
  // -----------------------------------------------------------------------------------------------------------------

  public function selectCapabilitiesWithRole( $role )
  {

    if ( is_object( $role ) && is_a( $role, 'WPDKRole' ) ) {
      $role = $role->name;
    }

    ob_start(); ?>

    <select>
    <?php foreach ( $this->arrayCapabilitiesByRole[$role] as $cap => $enabled ): ?>
      <option><?php echo $cap ?></option>
    <?php endforeach ?>
  </select>

    <?php
    $content = ob_get_contents();
    ob_end_clean();
    return $content;
  }

}


class WPDKCapabilities {

  const OPTION_KEY = '_wpdk_capabilities_extends';

  public $roleCapabilities;

  public $defaultCapabilities;

  public $capabilities;

  public $userCapabilities;

  public $allCapabilities;


  private $_extendedData;

  public static function getInstance()
  {
    static $instance = null;
    if ( is_null( $instance ) ) {
      $instance = new WPDKCapabilities();
    }
    return $instance;
  }

  private function __construct()
  {

    /* Get the extended data. */
    $this->_extendedData = get_option( self::OPTION_KEY );

    /* Preset WordPress capabilities list. */
    $this->defaultCapabilities = array_keys( $this->defaultCapabilities() );

    /* Get the role capabilities. */
    $this->roleCapabilities = array_keys( $this->roleCapabilities() );

    /* Get the role users. */
    $this->userCapabilities = array_keys( $this->userCapabilities() );

    /* Setup only plugin capabilities. */
    $this->capabilities = array_unique( array_merge( array_diff( $this->roleCapabilities, $this->defaultCapabilities ), $this->userCapabilities ) );
    sort( $this->capabilities );

    /* All caps */
    $this->allCapabilities = array_unique( array_merge( $this->userCapabilities, $this->roleCapabilities, $this->defaultCapabilities ) );
    sort( $this->allCapabilities );
  }

  public function get_cap( $cap_id )
  {
    $cap = false;
    if ( isset( $this->allCapabilities[$cap_id] ) ) {
      $description = '';
      $owner       = '';
      if ( isset( $this->_extendedData[$cap_id] ) ) {
        list( $cap_id, $description, $owner ) = $this->_extendedData[$cap_id];
      }
      $cap = new WPDKCapability( $cap_id, $description, $owner );
    }
    return $cap;
  }

  // -----------------------------------------------------------------------------------------------------------------
  // Capabilities list
  // -----------------------------------------------------------------------------------------------------------------

  public static function defaultCapabilities()
  {

    /* Create an array of all the default WordPress capabilities so the user doesn't accidentally get rid of them. */
    $defaults = array(
      'activate_plugins'       => array( 'activate_plugins', __( 'Allows access to Administration Panel options: Plugins', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'add_users'              => array( 'add_users', __( 'add_users', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'create_users'           => array( 'create_users', __( 'create_users', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'delete_others_pages'    => array( 'delete_others_pages', __( 'delete_others_pages', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'delete_others_posts'    => array( 'delete_others_posts', __( 'delete_others_posts', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'delete_pages'           => array( 'delete_pages', __( 'delete_pages', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'delete_plugins'         => array( 'delete_plugins', __( 'delete_plugins', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'delete_posts'           => array( 'delete_posts', __( 'delete_posts', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'delete_private_pages'   => array( 'delete_private_pages', __( 'delete_private_pages', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'delete_private_posts'   => array( 'delete_private_posts', __( 'delete_private_posts', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'delete_published_pages' => array( 'delete_published_pages', __( 'delete_published_pages', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'delete_published_posts' => array( 'delete_published_posts', __( 'delete_published_posts', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'delete_users'           => array( 'delete_users', __( 'delete_users', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'edit_dashboard'         => array( 'edit_dashboard', __( 'edit_dashboard', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'edit_files'             => array( 'edit_files', __( 'No longer used.', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'edit_others_pages'      => array( 'edit_others_pages', __( 'edit_others_pages', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'edit_others_posts'      => array( 'edit_others_posts', __( 'edit_others_posts', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'edit_pages'             => array( 'edit_pages', __( 'edit_pages', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'edit_plugins'           => array( 'edit_plugins', __( 'edit_plugins', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'edit_posts'             => array( 'edit_posts', __( 'edit_posts', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'edit_private_pages'     => array( 'edit_private_pages', __( 'edit_private_pages', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'edit_private_posts'     => array( 'edit_private_posts', __( 'edit_private_posts', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'edit_published_pages'   => array( 'edit_published_pages', __( 'edit_published_pages', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'edit_published_posts'   => array( 'edit_published_posts', __( 'edit_published_posts', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'edit_theme_options'     => array( 'edit_theme_options', __( 'Allows access to Administration Panel options: Appearance > Widgets, Appearance > Menus, Appearance > Theme Options if they are supported by the current theme, Appearance > Background, Appearance > Header ', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'edit_themes'            => array( 'edit_themes', __( 'edit_themes', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'edit_users'             => array( 'edit_users', __( 'Allows access to Administration Panel options: Users', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'import'                 => array( 'import', __( 'import', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'install_plugins'        => array( 'install_plugins', __( 'Allows access to Administration Panel options: Plugins > Add New ', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'install_themes'         => array( 'install_themes', __( 'Allows access to Administration Panel options: Appearance > Add New Themes', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'list_users'             => array( 'list_users', __( 'list_users', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'manage_categories'      => array( 'manage_categories', __( 'Allows access to Administration Panel options: Posts > Categories, Links > Categories', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'manage_links'           => array( 'manage_links', __( 'Allows access to Administration Panel options: Links Links > Add New', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'manage_options'         => array( 'manage_options', __( 'Allows access to Administration Panel options: Settings > General, Settings > Writing, Settings > Reading, Settings > Discussion, Settings > Permalinks, Settings > Miscellaneous', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'moderate_comments'      => array( 'moderate_comments', __( 'Allows users to moderate comments from the Comments SubPanel (although a user needs the edit_posts Capability in order to access this)', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'promote_users'          => array( 'promote_users', __( 'promote_users', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'publish_pages'          => array( 'publish_pages', __( 'publish_pages', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'publish_posts'          => array( 'publish_posts', __( 'See and use the "publish" button when editing their post (otherwise they can only save drafts). Can use XML-RPC to publish (otherwise they get a "Sorry, you can not post on this weblog or category.")', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'read'                   => array( 'read', __( 'Allows access to Administration Panel options: Dashboard, Users > Your Profile. Used nowhere in the core code except the menu.php', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'read_private_pages'     => array( 'read_private_pages', __( 'read_private_pages', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'read_private_posts'     => array( 'read_private_posts', __( 'read_private_posts', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'remove_users'           => array( 'remove_users', __( 'remove_users', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'switch_themes'          => array( 'switch_themes', __( 'Allows access to Administration Panel options: Appearance, Appearance > Themes ', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'unfiltered_html'        => array( 'unfiltered_html', __( 'Allows user to post HTML markup or even JavaScript code in pages, posts, and comments. Note: Enabling this option for untrusted users may result in their posting malicious or poorly formatted code. ', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'unfiltered_upload'      => array( 'unfiltered_upload', __( 'unfiltered_upload', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'update_core'            => array( 'update_core', __( 'update_core', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'update_plugins'         => array( 'update_plugins', __( 'update_plugins', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'update_themes'          => array( 'update_themes', __( 'update_themes', WPDK_TEXTDOMAIN ), 'WordPress' ),
      'upload_files'           => array( 'upload_files', __( 'Allows access to Administration Panel options: Media, Media > Add New ', WPDK_TEXTDOMAIN ), 'WordPress' ),
    );

    /* Return the array of default capabilities. */
    return apply_filters( 'wpdk_capabilities_defaults', $defaults );
  }

  private static function oldLevels()
  {
    $old_levels = array(
      'level_0'  => array( 'level_0', '', 'WordPress' ),
      'level_1'  => array( 'level_1', '', 'WordPress' ),
      'level_2'  => array( 'level_2', '', 'WordPress' ),
      'level_3'  => array( 'level_3', '', 'WordPress' ),
      'level_4'  => array( 'level_4', '', 'WordPress' ),
      'level_5'  => array( 'level_5', '', 'WordPress' ),
      'level_6'  => array( 'level_6', '', 'WordPress' ),
      'level_7'  => array( 'level_7', '', 'WordPress' ),
      'level_8'  => array( 'level_8', '', 'WordPress' ),
      'level_9'  => array( 'level_9', '', 'WordPress' ),
      'level_10' => array( 'level_10', '', 'WordPress' )
    );
    return apply_filters( 'wpdk_capabilities_old_levels', $old_levels );
  }


  public function roleCapabilities()
  {

    /* Get WPDKRoles */
    $wpdk_roles = WPDKRoles::getInstance();

    /* Set up an empty capabilities array. */
    $capabilities = array();

    /* Loop through each role object because we need to get the caps. */
    foreach ( $wpdk_roles->role_objects as $key => $role ) {

      /* Roles without capabilities will cause an error, so we need to check if $role->capabilities is an array. */
      if ( is_array( $role->capabilities ) ) {

        /* Loop through the role's capabilities and add them to the $capabilities array. */
        $exclude = self::oldLevels();
        foreach ( $role->capabilities as $cap => $grant ) {
          if ( !isset( $exclude[$cap] ) ) {
            $capabilities[$cap] = isset( $this->_extendedData[$cap] ) ? $this->_extendedData[$cap] : array(
              $cap,
              '',
              ''
            );
          }
        }
      }
    }

    /* Sort the capabilities by name so they're easier to read when shown on the screen. */
    ksort( $capabilities );

    /* Return the capabilities array */
    return $capabilities;
  }

  public function userCapabilities()
  {
    global $wpdb;

    //$capabilities = get_transient( '_wpdk_users_caps' );
    $capabilities = ''; // cache off for debug
    if ( empty( $capabilities ) ) {
      $sql    = "SELECT user_id, meta_value FROM `{$wpdb->usermeta}` WHERE meta_key = 'wp_capabilities'";
      $result = $wpdb->get_results( $sql, ARRAY_A );

      foreach ( $result as $user_cap ) {
        /* A cap is store with a bolean flah that here is ignored. */
        $temp = array_keys( unserialize( $user_cap['meta_value'] ) );
        foreach ( $temp as $key ) {
          $capabilities[$key] = isset( $this->_extendedData[$key] ) ? $this->_extendedData[$key] : array(
            $key,
            '',
            ''
          );
        }
      }
      //set_transient( '_wpdk_users_caps', $capabilities, 120 );
    }

    /* Sort the capabilities by name so they're easier to read when shown on the screen. */
    ksort( $capabilities );

    return $capabilities;

  }

  public function allCapabilities()
  {
    $capabilities = $this->userCapabilities();
    $capabilities = array_merge( $capabilities, $this->roleCapabilities() );
    $capabilities = array_merge( $capabilities, $this->defaultCapabilities() );

    /* Sort the capabilities by name so they're easier to read when shown on the screen. */
    ksort( $capabilities );

    return $capabilities;
  }


  // -------------------------------------------------------------------------------------------------------------------
  // Extra
  // -------------------------------------------------------------------------------------------------------------------

  public function usersCapability()
  {
    global $wpdb;

    //$user_caps = get_transient( '_wpdk_users_caps' );
    $user_caps = false; // cache off for debug
    if ( empty( $user_caps ) ) {
      $sql    = "SELECT user_id, meta_value FROM `{$wpdb->usermeta}` WHERE meta_key = 'wp_capabilities'";
      $result = $wpdb->get_results( $sql, ARRAY_A );

      foreach ( $result as $user_cap ) {
        $user_caps[$user_cap['user_id']] = get_userdata( $user_cap['user_id'] )->allcaps;
      }

      //set_transient( '_wpdk_users_caps', $user_caps, 120 );
    }
    return $user_caps;

  }

}


class WPDKCapability {

  public $id;

  public $description;

  public $owner;

  public function __construct( $id, $description = '', $owner = '' )
  {
    $this->id          = $id;
    $this->description = $description;
    $this->owner       = $owner;

  }

  public function update()
  {
    $extra = get_option( WPDKCapabilities::OPTION_KEY );
    if ( !empty( $extra ) ) {
      $extra[$this->id] = array(
        $this->id,
        $this->description,
        $this->owner
      );
    }
    else {
      $extra = WPDKCapabilities::getInstance()->capabilities;
    }
    return update_option( WPDKCapabilities::OPTION_KEY, $extra );
  }

}