class TaxonomyTerm

taxonomy_autoload_info in core/modules/taxonomy/taxonomy.module

Implements hook_autoload_info().

taxonomy_entity_info in core/modules/taxonomy/taxonomy.module

Implements hook_entity_info().

class TaxonomyTerm extends Entity {

  /**
   * The taxonomy term ID.
   *
   * @var integer
   */
  public $tid;

  /**
   * The machine name of the vocabulary to which the term is assigned.
   *
   * @var string
   */
  public $vocabulary;

  /**
   * Name of the term.
   *
   * @var string
   */
  public $name;

  /**
   * Language of the term.
   *
   * @var string
   */
  public $langcode = LANGUAGE_NONE;

  /**
   * (optional) Description of the term.
   *
   * @var string
   */
  public $description;

  /**
   * (optional) The text format name for the term's description.
   *
   * @var string
   */
  public $format;

  /**
   * (optional) The weight of this term in relation to other terms of the same
   * vocabulary.
   *
   * @var integer
   */
  public $weight = 0;

  /**
   * (optional) The parent term(s) for this term.
   *
   * This property is not loaded, but may be used to modify the term parents via
   * TaxonomyTerm::save().
   *
   * The property can be set to an array of term IDs. An entry of array(0) means
   * this term does not have any parents. When omitting this variable during an
   * update, the existing hierarchy for the term remains unchanged.
   *
   * @var array
   */
  public $parent;

  /**
   * Implements EntityInterface::id().
   */
  public function id() {
    return isset($this->tid) ? $this->tid : NULL;
  }

  /**
   * Implements EntityInterface::label().
   */
  public function label() {
    return $this->name;
  }

  /**
   * Implements EntityInterface::bundle().
   */
  public function bundle() {
    return $this->vocabulary;
  }

  /**
   * Implements EntityInterface::entityType().
   */
  public function entityType() {
    return 'taxonomy_term';
  }

  /**
   * Implements EntityInterface::uri()
   */
  public function uri() {
    return array(
      'path' => 'taxonomy/term/' . $this->tid,
      'options' => array(),
    );
  }

  /**
   * Overrides Entity::createAccess().
   */
  public static function createAccess($bundle = NULL, $account = NULL) {
    // If no user object is supplied, the access check is for the current user.
    if (empty($account)) {
      $account = $GLOBALS['user'];
    }

    $admin_access = user_access('administer taxonomy', $account);
    if (!empty($bundle)) {
      return user_access("create terms in $bundle", $account) || $admin_access;
    }
    return $admin_access;
  }

  /**
   * Overrides Entity::access().
   *
   * @param string $op
   *   The operation to be performed on the taxonomy term. Possible values are:
   *   - create
   *   - view
   *   - update
   *   - delete
   * @param User|AnonymousUser|object $account
   *   (optional) The user to check for. Leave it to NULL to check for the
   *   global user.
   *
   * @return bool
   *   TRUE if access is granted, FALSE otherwise.
   */
  public function access($op, $account = NULL) {
    if ($op == 'create') {
      return self::createAccess($this->bundle(), $account);
    }
    elseif (!in_array($op, array('view', 'update', 'delete'), TRUE)) {
      // If the $op was not one of the supported ones, we return access denied.
      return FALSE;
    }

    // If no user object is supplied, the access check is for the current user.
    if (empty($account)) {
      $account = $GLOBALS['user'];
    }

    if ($op == 'view') {
      return user_access('access content', $account);
    }
    elseif ($op == 'update') {
      return user_access("edit terms in $this->vocabulary", $account) || user_access('administer taxonomy', $account);
    }
    elseif ($op == 'delete') {
      return user_access("delete terms in $this->vocabulary", $account) || user_access('administer taxonomy', $account);
    }

    return FALSE;
  }

}