foldershare-8.x-1.2/src/Entity/FolderShareTraits/FindTrait.php

<?php
 
namespace Drupal\foldershare\Entity\FolderShareTraits;
 
use Drupal\Core\Database\Database;
use Drupal\file\FileInterface;
use Drupal\user\Entity\User;
 
/**
 * Find FolderShare entities.
 *
 * This trait includes find methods that query across all FolderShare
 * entities, or within a specific folder, and return IDs, entities, or
 * other values that match criteria.
 *
 * <B>Internal trait</B>
 * This trait is internal to the FolderShare module and used to define
 * features of the FolderShare entity class. It is a mechanism to group
 * functionality to improve code management.
 *
 * @ingroup foldershare
 */
trait FindTrait {
 
  /*---------------------------------------------------------------------
   *
   * Find root-level items.
   *
   *---------------------------------------------------------------------*/
 
  /**
   * Returns a list of root items that meet user and name requirements.
   *
   * An optional user ID may be provided to constrain root items to only
   * those owned by the specified user. If the ID is not given, or it is
   * FolderShareInterface::ANY_USER_ID, root items for any user are returned.
   *
   * An optional name may be provided to constrain root items to only those
   * with the given name. If a name is not given, or it is an empty string,
   * root items with any name are returned.
   *
   * System hidden or disabled root items may or may not be returned, depending
   * upon the parameters.
   *
   * Items marked disabled are in use. They remain visible and are enabled
   * again when they are no longer in use. Typically, disabled items should
   * be included in the returned results, so $includeDisabled defaults to
   * TRUE.
   *
   * Items marked hidden are being deleted. They are not visible and will
   * never be enabled again. Typically, hidden items should not be included
   * in the returned results, so $includeHidden defaults to FALSE.
   *
   * <B>Memory use</B>
   * Warning: There can be a large number of root items. Loading them all
   * into memory at the same time could exceed PHP's memory limit.
   *
   * <B>Run time</B>
   * Warning: There can be a large number of root items. Loading them all
   * at the same time could exceed PHP's execution time limit.
   *
   * <B>Example usage</B>
   * Find all root items for all users, for a specific user, or
   * for a specific user and named "data":
   * @code
   *   $allRootItems = FolderShare::findAllRootItems();
   *
   *   $user = \Drupal::currentUser();
   *   $allRootItemsByUser = FolderShare::findAllRootItems($user->id());
   *
   *   $allRootItemsByUserNamedData = FolderShare::findAllRootItems($user->id(), "data");
   * @endcode
   *
   * @param int $ownerUid
   *   (optional, default = FolderShareInterface::ANY_USER_ID) The user ID for
   *   the root items' owner.
   * @param string $name
   *   (optional, default = '' = any) The name for the root items.
   * @param bool $includeDisabled
   *   (optional, default = TRUE) When TRUE, disabled root items are included.
   *   When FALSE, they are not.
   * @param bool $includeHidden
   *   (optional, default = FALSE) When TRUE, hidden root items are included.
   *   When FALSE, they are not.
   *
   * @return \Drupal\foldershare\FolderShareInterface[]
   *   Returns an unordered associative array where keys are entity IDs
   *   and values are entities for root items.
   *
   * @see ::findAllIds()
   * @see ::findAllRootItemNames()
   * @see ::findAllPublicRootItems()
   * @see ::findAllSharedRootItems()
   */
  public static function findAllRootItems(
    int $ownerUid = self::ANY_USER_ID,
    string $name = '',
    bool $includeDisabled = TRUE,
    bool $includeHidden = FALSE) {
 
    $ids = self::findAllRootItemIds(
      $ownerUid,
      $name,
      $includeDisabled,
      $includeHidden);
 
    if (empty($ids) === TRUE) {
      return [];
    }
 
    return self::loadMultiple($ids);
  }
 
  /**
   * Returns a list of root item IDs that meet user and name requirements.
   *
   * An optional user ID may be provided to constrain root items to only
   * those owned by the specified user. If the ID is not given, or it is
   * FolderShareInterface::ANY_USER_ID, root items for any user are returned.
   *
   * An optional name may be provided to constrain root items to only those
   * with the given name. If a name is not given, or it is an empty string,
   * root items with any name are returned.
   *
   * System hidden or disabled root items may or may not be returned, depending
   * upon the parameters.
   *
   * Items marked disabled are in use. They remain visible and are enabled
   * again when they are no longer in use. Typically, disabled items should
   * be included in the returned results, so $includeDisabled defaults to
   * TRUE.
   *
   * Items marked hidden are being deleted. They are not visible and will
   * never be enabled again. Typically, hidden items should not be included
   * in the returned results, so $includeHidden defaults to FALSE.
   *
   * <B>Example usage</B>
   * Find all root item IDs for all users, for a specific user, or
   * for a specific user and named "data":
   * @code
   *   $allRootItemIds = FolderShare::findAllRootItemIds();
   *
   *   $user = \Drupal::currentUser();
   *   $allRootItemIdsByUser = FolderShare::findAllRootItemIds($user->id());
   *
   *   $allRootItemIdsByUserNamedData = FolderShare::findAllRootItemIds($user->id(), "data");
   * @endcode
   *
   * @param int $ownerUid
   *   (optional, default = FolderShareInterface::ANY_USER_ID) The user ID
   *   for the root items' owner.
   * @param string $name
   *   (optional, default = '' = any) The name for the root items.
   * @param bool $includeDisabled
   *   (optional, default = TRUE) When TRUE, disabled root items are included.
   *   When FALSE, they are not.
   * @param bool $includeHidden
   *   (optional, default = FALSE) When TRUE, hidden root items are included.
   *   When FALSE, they are not.
   *
   * @return int[]
   *   An unordered list of integer entity IDs for root items.
   *
   * @see ::findAllIds()
   * @see ::findAllRootItems()
   * @see ::findAllRootItemNames()
   */
  public static function findAllRootItemIds(
    int $ownerUid = self::ANY_USER_ID,
    string $name = '',
    bool $includeDisabled = TRUE,
    bool $includeHidden = FALSE) {
 
    // Root items have no parent ID or root ID.
    $connection = Database::getConnection();
    $select = $connection->select(self::BASE_TABLE, 'fs');
    $select->addField('fs', 'id', 'id');
    $select->isNull('parentid');
 
    if ($includeDisabled === FALSE) {
      // An empty field is also FALSE, so we have to test for !TRUE.
      $select->condition('systemdisabled', TRUE, '<>');
    }
 
    if ($includeHidden === FALSE) {
      // An empty field is also FALSE, so we have to test for !TRUE.
      $select->condition('systemhidden', TRUE, '<>');
    }
 
    if ($ownerUid >= 0) {
      $select->condition('uid', $ownerUid, '=');
    }
 
    if (empty($name) === FALSE) {
      $select->condition('name', $name, '=');
    }
 
    return $select->execute()->fetchCol(0);
  }
 
  /**
   * Returns a list of root item names that meet user requirements.
   *
   * An optional user ID may be provided to constrain root items to only
   * those owned by the specified user. If the ID is not given, or it is
   * FolderShareInterface::ANY_USER_ID, root items for any user are returned.
   *
   * System hidden or disabled root items may or may not be returned, depending
   * upon the parameters.
   *
   * Items marked disabled are in use. They remain visible and are enabled
   * again when they are no longer in use. Typically, disabled items should
   * be included in the returned results, so $includeDisabled defaults to
   * TRUE.
   *
   * Items marked hidden are being deleted. They are not visible and will
   * never be enabled again. Typically, hidden items should not be included
   * in the returned results, so $includeHidden defaults to FALSE.
   *
   * <B>Example usage</B>
   * Find all root item names for all users or for a specific user:
   * @code
   *   $allRootItems = FolderShare::findAllRootItemNames();
   *
   *   $user = \Drupal::currentUser();
   *   $rootItemNames = FolderShare::findAllRootItemNames($user->id());
   * @endcode
   *
   * @param int $ownerUid
   *   (optional, default = FolderShareInterface:ANY_USER_ID) The user ID
   *   for the root item's owner.
   * @param bool $includeDisabled
   *   (optional, default = TRUE) When TRUE, disabled root items are included.
   *   When FALSE, they are not.
   * @param bool $includeHidden
   *   (optional, default = FALSE) When TRUE, hidden root items are included.
   *   When FALSE, they are not.
   *
   * @return array
   *   Returns an unordered associative array where keys are entity names
   *   and values are entity IDs for root items.
   *
   * @see ::findAllIds()
   * @see ::findAllRootItems()
   * @see ::findAllRootItemIds()
   */
  public static function findAllRootItemNames(
    int $ownerUid = self::ANY_USER_ID,
    bool $includeDisabled = TRUE,
    bool $includeHidden = FALSE) {
 
    // Root items have no parent ID or root ID.
    $connection = Database::getConnection();
    $select = $connection->select(self::BASE_TABLE, 'fs');
    $select->addField('fs', 'id', 'id');
    $select->addField('fs', 'name', 'name');
    $select->isNull('parentid');
 
    if ($includeDisabled === FALSE) {
      // An empty field is also FALSE, so we have to test for !TRUE.
      $select->condition('systemdisabled', TRUE, '<>');
    }
 
    if ($includeHidden === FALSE) {
      // An empty field is also FALSE, so we have to test for !TRUE.
      $select->condition('systemhidden', TRUE, '<>');
    }
 
    if ($ownerUid >= 0) {
      $select->condition('uid', $ownerUid, '=');
    }
 
    $names = [];
    foreach ($select->execute() as $result) {
      $names[$result->name] = (int) $result->id;
    }
 
    return $names;
  }
 
  /**
   * Returns a list of public root items that meet user and name requirements.
   *
   * A public root item is one that is owned by the anonymous user OR one that
   * grants view access to anonymous.
   *
   * An optional user ID may be provided to constrain root items to only
   * those owned by the specified user. If the ID is not given, or it is
   * FolderShareInterface::ANY_USER_ID, root items for any user are returned.
   *
   * An optional name may be provided to constrain root items to only those
   * with the given name. If a name is not given, or it is an empty string,
   * root items with any name are returned.
   *
   * System hidden or disabled root items may or may not be returned, depending
   * upon the parameters.
   *
   * Items marked disabled are in use. They remain visible and are enabled
   * again when they are no longer in use. Typically, disabled items should
   * be included in the returned results, so $includeDisabled defaults to
   * TRUE.
   *
   * Items marked hidden are being deleted. They are not visible and will
   * never be enabled again. Typically, hidden items should not be included
   * in the returned results, so $includeHidden defaults to FALSE.
   *
   * <B>Memory use</B>
   * Warning: There can be a large number of root items. Loading them all
   * into memory at the same time could exceed PHP's memory limit.
   *
   * <B>Run time</B>
   * Warning: There can be a large number of root items. Loading them all
   * at the same time could exceed PHP's execution time limit.
   *
   * @param int $ownerUid
   *   (optional, default = FolderShareInterface::ANY_USER_ID) The user ID
   *   for the root items' owner.
   * @param string $name
   *   (optional, default = '' = any) The name for the root items.
   * @param bool $includeDisabled
   *   (optional, default = TRUE) When TRUE, disabled root items are included.
   *   When FALSE, they are not.
   * @param bool $includeHidden
   *   (optional, default = FALSE) When TRUE, hidden root items are included.
   *   When FALSE, they are not.
   *
   * @return \Drupal\foldershare\FolderShareInterface[]
   *   Returns an unordered associative array where keys are entity IDs
   *   and values are entities for root items.
   *
   * @see ::findAllPublicRootItemIds()
   * @see ::findAllRootItems()
   * @see ::findAllSharedRootItems()
   */
  public static function findAllPublicRootItems(
    int $ownerUid = self::ANY_USER_ID,
    string $name = '',
    bool $includeDisabled = TRUE,
    bool $includeHidden = FALSE) {
 
    $ids = self::findAllPublicRootItemIds(
      $ownerUid,
      $name,
      TRUE,
      FALSE);
 
    if (empty($ids) === TRUE) {
      return [];
    }
 
    return self::loadMultiple($ids);
  }
 
  /**
   * Returns a list of public root IDs that meet user and name requirements.
   *
   * A public root item is one that is owned by the anonymous user OR one that
   * grants view access to anonymous.
   *
   * An optional user ID may be provided to constrain root items to only
   * those owned by the specified user. If the ID is not given, or it is
   * FolderShareInterface::ANY_USER_ID, root items for any user are returned.
   *
   * An optional name may be provided to constrain root items to only those
   * with the given name. If a name is not given, or it is an empty string,
   * root items with any name are returned.
   *
   * System hidden or disabled root items may or may not be returned, depending
   * upon the parameters.
   *
   * Items marked disabled are in use. They remain visible and are enabled
   * again when they are no longer in use. Typically, disabled items should
   * be included in the returned results, so $includeDisabled defaults to
   * TRUE.
   *
   * Items marked hidden are being deleted. They are not visible and will
   * never be enabled again. Typically, hidden items should not be included
   * in the returned results, so $includeHidden defaults to FALSE.
   *
   * <B>Example usage</B>
   * Find all public root item IDs for all users, for a specific user, or
   * for a specific user and named "data":
   * @code
   *   $allPublicRootItemIds = FolderShare::findAllPublicRootItemIds();
   *
   *   $user = \Drupal::currentUser();
   *   $allPublicRootItemIdsByUser = FolderShare::findAllPublicRootItemIds($user->id());
   *
   *   $allPublicRootItemsIdsByUserNamedData = FolderShare::findAllPublicRootItemIds($user->id(), "data");
   * @endcode
   *
   * @param int $ownerUid
   *   (optional, default = FolderShareInterface::ANY_USER_ID) The user ID
   *   for the root items' owner.
   * @param string $name
   *   (optional, default = '' = any) The name for the root items.
   * @param bool $includeDisabled
   *   (optional, default = TRUE) When TRUE, disabled root items are included.
   *   When FALSE, they are not.
   * @param bool $includeHidden
   *   (optional, default = FALSE) When TRUE, hidden root items are included.
   *   When FALSE, they are not.
   *
   * @return int[]
   *   Returns an unordered array of entity IDs.
   *
   * @see ::findAllRootItemsIds()
   * @see ::findAllSharedRootItemsIds()
   */
  public static function findAllPublicRootItemIds(
    int $ownerUid = self::ANY_USER_ID,
    string $name = '',
    bool $includeDisabled = TRUE,
    bool $includeHidden = FALSE) {
 
    // Root items have no parent ID or root ID.
    $connection = Database::getConnection();
    $select = $connection->select(self::BASE_TABLE, 'fs');
    $select->addField('fs', 'id', 'id');
    $select->condition('parentid', NULL, 'IS NULL');
 
    if ($includeDisabled === FALSE) {
      // An empty field is also FALSE, so we have to test for !TRUE.
      $select->condition('systemdisabled', TRUE, '<>');
    }
 
    if ($includeHidden === FALSE) {
      // An empty field is also FALSE, so we have to test for !TRUE.
      $select->condition('systemhidden', TRUE, '<>');
    }
 
    // Join with the list of people granted view access.
    $select->join(
      'foldershare__grantviewuids',
      'view',
      '(view.entity_id = fs.id)');
 
    // Then require one of these cases:
    // - The item's owner is anonymous.
    // - The grants for view access include anonymous.
    $anonymousUid = (int) User::getAnonymousUser()->id();
    $group = $select->orConditionGroup()
      ->condition('uid', $anonymousUid, '=')
      ->condition('view.grantviewuids_target_id', $anonymousUid, '=');
    $select = $select->condition($group);
 
    // Constrain results to those owned by a specified user, or with
    // the specified item name.
    if ($ownerUid >= 0) {
      $select->condition('uid', $ownerUid, '=');
    }
 
    if (empty($name) === FALSE) {
      $select->condition('name', $name, '=');
    }
 
    return $select->execute()->fetchCol(0);
  }
 
  /**
   * Returns a list of shared root items that meet user and name requirements.
   *
   * A shared root item is one that is not owned by the current user AND one
   * that grants view access to the current user.
   *
   * An optional user ID may be provided to constrain root items to only
   * those owned by the specified user. If the ID is not given, or it is
   * FolderShareInterface::ANY_USER_ID, root items for any user are returned.
   *
   * An optional viewer ID may be provided to constrain root items to only
   * those viewable by the specified user. If the ID is not given, or it is
   * FolderShareInterface::CURRENT_USER_ID, root items viewable by the current
   * user are returned.
   *
   * An optional name may be provided to constrain root items to only those
   * with the given name. If a name is not given, or it is an empty string,
   * root items with any name are returned.
   *
   * System hidden or disabled root items may or may not be returned, depending
   * upon the parameters.
   *
   * Items marked disabled are in use. They remain visible and are enabled
   * again when they are no longer in use. Typically, disabled items should
   * be included in the returned results, so $includeDisabled defaults to
   * TRUE.
   *
   * Items marked hidden are being deleted. They are not visible and will
   * never be enabled again. Typically, hidden items should not be included
   * in the returned results, so $includeHidden defaults to FALSE.
   *
   * <B>Memory use</B>
   * Warning: There can be a large number of root items. Loading them all
   * into memory at the same time could exceed PHP's memory limit.
   *
   * <B>Run time</B>
   * Warning: There can be a large number of root items. Loading them all
   * at the same time could exceed PHP's execution time limit.
   *
   * @param int $ownerUid
   *   (optional, default = FolderShareInterface::ANY_USR_ID) The user ID
   *   for the root items owner.
   * @param int $viewerUid
   *   (optional, default = FolderShareInterface::CURRENT_USER_ID) The user ID
   *   for the user that must have view permission (defaults to current user).
   * @param string $name
   *   (optional, default = '' = any) The name for the root items.
   * @param bool $includeDisabled
   *   (optional, default = TRUE) When TRUE, disabled root items are included.
   *   When FALSE, they are not.
   * @param bool $includeHidden
   *   (optional, default = FALSE) When TRUE, hidden root items are included.
   *   When FALSE, they are not.
   *
   * @return \Drupal\foldershare\FolderShareInterface[]
   *   Returns an unordered associative array where keys are entity IDs
   *   and values are entities for root items.
   *
   * @see ::findAllPublicRootItems()
   * @see ::findAllRootItems()
   * @see ::findAllSharedRootItemIds()
   */
  public static function findAllSharedRootItems(
    int $ownerUid = self::ANY_USER_ID,
    int $viewerUid = self::CURRENT_USER_ID,
    string $name = '',
    bool $includeDisabled = TRUE,
    bool $includeHidden = FALSE) {
 
    $ids = self::findAllSharedRootItemIds(
      $ownerUid,
      $viewerUid,
      $name,
      $includeDisabled,
      $includeHidden);
 
    if (empty($ids) === TRUE) {
      return [];
    }
 
    return self::loadMultiple($ids);
  }
 
  /**
   * Returns a list of shared root IDs that meet user and name requirements.
   *
   * A shared root item is one that is not owned by the current user AND one
   * that grants view access to the current user.
   *
   * An optional user ID may be provided to constrain root items to only
   * those owned by the specified user. If the ID is not given, or it is
   * FolderShareInterface::ANY_USER_ID, root items for any user are returned.
   *
   * An optional viewer ID may be provided to constrain root items to only
   * those viewable by the specified user. If the ID is not given, or it is
   * FolderShareInterface::CURRENT_USER_ID, root items viewable by the current
   * user are returned.
   *
   * An optional name may be provided to constrain root items to only those
   * with the given name. If a name is not given, or it is an empty string,
   * root items with any name are returned.
   *
   * System hidden or disabled root items may or may not be returned, depending
   * upon the parameters.
   *
   * Items marked disabled are in use. They remain visible and are enabled
   * again when they are no longer in use. Typically, disabled items should
   * be included in the returned results, so $includeDisabled defaults to
   * TRUE.
   *
   * Items marked hidden are being deleted. They are not visible and will
   * never be enabled again. Typically, hidden items should not be included
   * in the returned results, so $includeHidden defaults to FALSE.
   *
   * <B>Example usage</B>
   * Find all shared root item IDs for all users, for a specific user, or
   * for a specific user and named "data":
   * @code
   *   $allSharedRootItemIds = FolderShare::findAllSharedRootItemIds();
   *
   *   $user = \Drupal::currentUser();
   *   $allSharedRootItemIdsByUser = FolderShare::findAllSharedRootItemIds($user->id());
   *
   *   $allSharedRootItemIdsByUserNamedData = FolderShare::findAllSharedRootItemIds($user->id(), "data");
   * @endcode
   *
   * @param int $ownerUid
   *   (optional, default = FolderShareInterface::ANY_USR_ID) The user ID
   *   for the root items owner.
   * @param int $viewerUid
   *   (optional, default = FolderShareInterface::CURRENT_USER_ID) The user ID
   *   for the user that must have view permission (defaults to current user).
   * @param string $name
   *   (optional, default = '' = any) The name for the root items.
   * @param bool $includeDisabled
   *   (optional, default = TRUE) When TRUE, disabled root items are included.
   *   When FALSE, they are not.
   * @param bool $includeHidden
   *   (optional, default = FALSE) When TRUE, hidden root items are included.
   *   When FALSE, they are not.
   *
   * @return int[]
   *   Returns an unordered array of entity IDs.
   *
   * @see ::findAllPublicRootItemIds()
   * @see ::findAllRootItemIds()
   */
  public static function findAllSharedRootItemIds(
    int $ownerUid = self::ANY_USER_ID,
    int $viewerUid = self::CURRENT_USER_ID,
    string $name = '',
    bool $includeDisabled = TRUE,
    bool $includeHidden = FALSE) {
 
    // Root items have no parent ID or root ID.
    $connection = Database::getConnection();
    $select = $connection->select(self::BASE_TABLE, 'fs');
    $select->addField('fs', 'id', 'id');
    $select->isNull('fs.parentid');
 
    if ($includeDisabled === FALSE) {
      // An empty field is also FALSE, so we have to test for !TRUE.
      $select->condition('systemdisabled', TRUE, '<>');
    }
 
    if ($includeHidden === FALSE) {
      // An empty field is also FALSE, so we have to test for !TRUE.
      $select->condition('systemhidden', TRUE, '<>');
    }
 
    // If a required owner ID is given, add a condition.
    if ($ownerUid >= 0) {
      $select->condition('uid', $ownerUid, '=');
    }
 
    // If a required item name is given, add a condition.
    if (empty($name) === FALSE) {
      $select->condition('name', $name, '=');
    }
 
    // If a required viewer ID is given, add a join and condition.
    if ($viewerUid >= 0) {
      if ($ownerUid < 0) {
        $select->condition('uid', $viewerUid, '<>');
      }
 
      $select->join(
        'foldershare__grantviewuids',
        'view',
        '(view.entity_id = fs.id)');
      $select->condition('view.grantviewuids_target_id', $viewerUid, '=');
    }
 
    return $select->execute()->fetchCol(0);
  }
 
  /*---------------------------------------------------------------------
   *
   * All items.
   *
   *---------------------------------------------------------------------*/
 
  /**
   * Returns a list of item IDs that meet user requirements.
   *
   * An optional user ID may be provided to constrain items to only
   * those owned by the specified user. If the ID is not given, or it is
   * FolderShareInterface::ANY_USER_ID, items for any user are returned.
   *
   * System hidden and disabled items may be included in the list.
   *
   * <B>Example usage</B>
   * Find all item IDs for all users, or all item IDs owned by a specific user:
   * @code
   *   $allItemIds = FolderShare::findAllIds();
   *
   *   $user = \Drupal::currentUser();
   *   $allItemIdsForUser = FolderShare::findAllIds($user->id());
   * @endcode
   *
   * @param int $ownerUid
   *   (optional, default = FolderShareInterface::ANY_USER_ID) The user ID
   *   for the items' owner.
   *
   * @return int[]
   *   An unordered list of integer entity IDs for items.
   *
   * @see ::findAllFoldersAndUserIds()
   * @see ::findAllRootItemIds()
   * @see ::countNumberOfFolders()
   */
  public static function findAllIds(int $ownerUid = self::ANY_USER_ID) {
 
    $query = \Drupal::entityQuery(self::BASE_TABLE);
    if ($ownerUid >= 0) {
      $query->condition('uid', $ownerUid, '=');
    }
 
    return $query->execute();
  }
 
  /*---------------------------------------------------------------------
   *
   * Count queries.
   *
   *---------------------------------------------------------------------*/
 
  /**
   * Returns the total number of bytes used by all files or images.
   *
   * When an optional user ID is provided, the returned total only includes
   * items owned by that user. When the user ID is not provided or is
   * FolderShareInterface::ANY_USER_ID, the returned total is for all users.
   *
   * The returned total only includes space used by stored files or images.
   * Folders and media items are not included. The storage space used for
   * database entries for files and images is not included.
   *
   * System hidden and disabled items may be included in the count.
   *
   * <B>Example usage</B>
   * Get the total amount of non-volatile (e.g. disk) storage space in use
   * for files (but not counting the database itself):
   * @code
   *   $bytes = FolderShare::countNumberOfBytes();
   * @endcode
   *
   * @param int $ownerUid
   *   (optional, default = FolderShareInterface::ANY_USER_ID) The user ID
   *   for the user for whome the count is returned. A value of
   *   FolderShareInterface::ANY_USER_ID returns a total for all users.
   *
   * @return int
   *   Returns the total number of bytes used for files and images.
   *
   * @see ::countNumberOfFiles()
   * @see ::countNumberOfFolders()
   * @see ::hasFiles()
   * @see ::hasFolders()
   */
  public static function countNumberOfBytes(
    int $ownerUid = self::ANY_USER_ID) {
 
    $connection = Database::getConnection();
    $select = $connection->select(self::BASE_TABLE, 'fs');
    $group = $select->orConditionGroup()
      ->condition('kind', self::FILE_KIND, '=')
      ->condition('kind', self::IMAGE_KIND, '=')
      ->condition('kind', self::MEDIA_KIND, '=');
    $select->condition($group);
    $select->addExpression('SUM(size)');
 
    if ($ownerUid >= 0) {
      $select->condition('uid', $ownerUid, '=');
    }
 
    return (int) $select->execute()->fetchField();
  }
 
  /**
   * Counts the total number of items.
   *
   * The returned value counts all FolderShare entities of any kind,
   * including folders, files, images, and media.
   *
   * System hidden and disabled items may be included in the count.
   *
   * <B>Example usage</B>
   * Get the total number of items of any kind:
   * @code
   *   $count = FolderShare::countNumberOfItems();
   * @endcode
   *
   * @param int $ownerUid
   *   (optional, default = FolderShareInterface::ANY_USER_ID) The user ID
   *   for the user for whome the count is returned. A value of
   *   FolderShareInterface::ANY_USER_ID returns a total for all users.
   *
   * @return int
   *   Returns the total number of items.
   *
   * @see ::findAllIds()
   * @see ::countNumberOfBytes()
   * @see ::countNumberOfFiles()
   * @see ::countNumberOfFolders()
   * @see ::hasFiles()
   * @see ::hasFolders()
   */
  public static function countNumberOfItems(
    int $ownerUid = self::ANY_USER_ID) {
 
    $connection = Database::getConnection();
    $select = $connection->select(self::BASE_TABLE, 'fs');
 
    if ($ownerUid >= 0) {
      $select->condition('uid', $ownerUid, '=');
    }
 
    return (int) $select->countQuery()->execute()->fetchField();
  }
 
  /**
   * Counts the total number of file, image, and media items.
   *
   * When an optional user ID is given, the returned total only includes
   * items owned by that user. When the user ID is not provided or is
   * FolderShareInterface::ANY_USER_ID, the returned total is for all users.
   *
   * The returned total counts all FolderShare file, image, and media kinds.
   * Folders are not included.
   *
   * System hidden and disabled items may be included in the count.
   *
   * <B>Example usage</B>
   * Get the total number of file, image, or media items;
   * @code
   *   $count = FolderShare::countNumberOfFiles();
   * @endcode
   *
   * @param int $ownerUid
   *   (optional, default = FolderShareInterface::ANY_USER_ID) The user ID
   *   for the user for whome the count is returned. A value of
   *   FolderShareInterface::ANY_USER_ID returns a total for all users.
   *
   * @return int
   *   Returns the total number of file, image, and media items.
   *
   * @see ::findAllIds()
   * @see ::countNumberOfBytes()
   * @see ::countNumberOfFolders()
   * @see ::hasFiles()
   * @see ::hasFolders()
   */
  public static function countNumberOfFiles(
    int $ownerUid = self::ANY_USER_ID) {
 
    $connection = Database::getConnection();
    $select = $connection->select(self::BASE_TABLE, 'fs');
 
    $group = $select->orConditionGroup()
      ->condition('kind', self::FILE_KIND, '=')
      ->condition('kind', self::IMAGE_KIND, '=')
      ->condition('kind', self::MEDIA_KIND, '=');
 
    $select = $select->condition($group);
 
    if ($ownerUid >= 0) {
      $select->condition('uid', $ownerUid, '=');
    }
 
    return (int) $select->countQuery()->execute()->fetchField();
  }
 
  /**
   * Counts the total number of folders managed by the module.
   *
   * When an optional user ID is given, the returned total only includes
   * items owned by that user. When the user ID is not provided or is
   * FolderShareInterface::ANY_USER_ID, the returned total is for all users.
   *
   * The returned total counts all FolderShare folders. Files, images,
   * and media items are not included.
   *
   * System hidden and disabled items may be included in the count.
   *
   * <B>Example usage</B>
   * Get the total number of folders:
   * @code
   *   $count = FolderShare::countNumberOfFolders();
   * @endcode
   *
   * @param int $ownerUid
   *   (optional, default = FolderShareInterface::ANY_USER_ID) The user ID
   *   for the user for whome the count is returned. A value of
   *   FolderShareInterface::ANY_USER_ID returns a total for all users.
   *
   * @return int
   *   Returns the total number of folders.
   *
   * @see ::findAllIds()
   * @see ::countNumberOfBytes()
   * @see ::countNumberOfFiles()
   * @see ::hasFiles()
   * @see ::hasFolders()
   */
  public static function countNumberOfFolders(
    int $ownerUid = self::ANY_USER_ID) {
 
    $connection = Database::getConnection();
    $select = $connection->select(self::BASE_TABLE, 'fs')
      ->condition('kind', self::FOLDER_KIND, '=');
 
    if ($ownerUid >= 0) {
      $select->condition('uid', $ownerUid, '=');
    }
 
    return (int) $select->countQuery()->execute()->fetchField();
  }
 
  /**
   * Returns TRUE if there are any files, images, or media.
   *
   * System hidden and disabled items may be included.
   *
   * @return bool
   *   Returns TRUE if there are any files, and FALSE otherwise.
   *
   * @see ::countNumberOfBytes()
   * @see ::countNumberOfFiles()
   * @see ::countNumberOfFolders()
   * @see ::hasFolders()
   */
  public static function hasFiles() {
    return (self::countNumberOfFiles() !== 0);
  }
 
  /**
   * Returns TRUE if there are any folders.
   *
   * System hidden and disabled items may be included.
   *
   * @return bool
   *   Returns TRUE if there are any folders, and FALSE otherwise.
   *
   * @see ::countNumberOfBytes()
   * @see ::countNumberOfFiles()
   * @see ::countNumberOfFolders()
   * @see ::hasFiles()
   */
  public static function hasFolders() {
    return (self::countNumberOfFolders() !== 0);
  }
 
  /*---------------------------------------------------------------------
   *
   * Find FolderShare entity by wrapped file or media.
   *
   *---------------------------------------------------------------------*/
 
  /**
   * Finds the FolderShare entity ID wrapping the given File entity.
   *
   * The database is queried to find a file or image FolderShare entity
   * that uses an entity reference to the given file. The ID of the entity
   * is returned, or (1) if no entity is found.
   *
   * A system hidden or disabled item may be returned.
   *
   * @param \Drupal\file\FileInterface $file
   *   The File entity used to search for a FolderShare entity that wraps it.
   *
   * @return bool|int
   *   Returns the FolderShare entity ID of the file or image item that
   *   wraps the given File entity, or a FALSE if not found. If $file is NULL,
   *   a FALSE is returned.
   */
  public static function findFileWrapperId(FileInterface $file) {
    if ($file === NULL) {
      return FALSE;
    }
 
    // Search the database for use of the file's ID in the target ID
    // of the 'file' or 'image' fields.
    $id = $file->id();
 
    $connection = Database::getConnection();
    $query = $connection->select(self::BASE_TABLE, 'fs');
    $query->addField('fs', 'id', 'id');
    $group = $query->orConditionGroup()
      ->condition('file__target_id', $id, '=')
      ->condition('image__target_id', $id, '=');
    $query = $query->condition($group);
    $results = $query->execute()
      ->fetchAll();
 
    if (empty($results) === TRUE) {
      return FALSE;
    }
 
    // There should be at most one entry.
    return (int) $results[0]->id;
  }
 
  /**
   * Finds the FolderShare entity ID wrapping the given Media entity.
   *
   * The database is queried to find a media FolderShare entity that uses an
   * entity reference to the given media entity. The ID of the entity
   * is returned, or (1) if no entity is found.
   *
   * A system hidden or disabled item may be returned.
   *
   * @param \Drupal\media\MediaInterface $media
   *   The Media entity used to search for a FolderShare entity that wraps it.
   *
   * @return int
   *   Returns the FolderShare entity ID of the media item that
   *   wraps the given File entity, or a FALSE if not found. If $media is NULL,
   *   a FALSE is returned.
   */
  public static function findMediaWrapperId(MediaInterface $media) {
    if ($media === NULL) {
      return FALSE;
    }
 
    // Search the database for use of the media's ID in the target ID
    // of the 'media' field.
    $connection = Database::getConnection();
    $query = $connection->select(self::BASE_TABLE, 'fs');
    $query->addField('fs', 'id', 'id');
    $query->condition('media__target_id', $media->id(), '=');
    $results = $query->execute()
      ->fetchAll();
 
    if (empty($results) === TRUE) {
      return FALSE;
    }
 
    // There should be at most one entry.
    return (int) $results[0]->id;
  }
 
  /*---------------------------------------------------------------------
   *
   * Find FolderShare entity by name.
   *
   *---------------------------------------------------------------------*/
 
  /**
   * Finds the ID for a named child within a parent folder.
   *
   * The $parentId argument selects the parent folder to search. If the
   * ID is not valid, the search will not find a match and FALSE is returned.
   *
   * A $name argument indicates the name to child name to search for. If the
   * name is empty, the search will not find a match and FALSE is returned.
   *
   * Since each child of a folder must have a unique name within the folder,
   * this search through a folder's children can return at most one matching
   * child. That single entity ID is returned, or FALSE if no matching
   * child was found.
   *
   * A system hidden or disabled item may be returned.
   *
   * @param int $parentId
   *   The parent folder ID.
   * @param string $name
   *   The name of an item to find.
   *
   * @return bool|int
   *   Returns the entity ID if the item with the given name and parent
   *   folder, or a FALSE if not found.
   */
  public static function findNamedChildId(int $parentId, string $name) {
    if ($parentId < 0 || empty($name) === TRUE) {
      return FALSE;
    }
 
    $connection = Database::getConnection();
    $select = $connection->select(self::BASE_TABLE, 'fs');
    $select->addField('fs', 'id', 'id');
    $select->condition('parentid', $parentId, '=');
    $select->condition('name', $name, '=');
    $ids = $select->execute()->fetchCol(0);
 
    if (empty($ids) === TRUE) {
      return FALSE;
    }
 
    // There should be at most one entry.
    return (int) $ids[0];
  }
 
  /*---------------------------------------------------------------------
   *
   * Find children.
   *
   *---------------------------------------------------------------------*/
 
  /**
   * {@inheritdoc}
   */
  public function findChildrenIds(
    bool $includeDisabled = TRUE,
    bool $includeHidden = FALSE) {
 
    if ($this->isFolder() === FALSE) {
      return [];
    }
 
    $connection = Database::getConnection();
    $select = $connection->select(self::BASE_TABLE, 'fs');
    $select->addField('fs', 'id', 'id');
    $select->condition('parentid', $this->id(), '=');
 
    if ($includeDisabled === FALSE) {
      // An empty field is also FALSE, so we have to test for !TRUE.
      $select->condition('systemdisabled', TRUE, '<>');
    }
 
    if ($includeHidden === FALSE) {
      // An empty field is also FALSE, so we have to test for !TRUE.
      $select->condition('systemhidden', TRUE, '<>');
    }
 
    return $select->execute()->fetchCol(0);
  }
 
  /**
   * {@inheritdoc}
   */
  public function findChildrenNames(
    bool $includeDisabled = TRUE,
    bool $includeHidden = FALSE) {
 
    if ($this->isFolder() === FALSE) {
      return [];
    }
 
    $connection = Database::getConnection();
    $select = $connection->select(self::BASE_TABLE, 'fs');
    $select->addField('fs', 'id', 'id');
    $select->addField('fs', 'name', 'name');
    $select->condition('parentid', $this->id(), '=');
 
    if ($includeDisabled === FALSE) {
      // An empty field is also FALSE, so we have to test for !TRUE.
      $select->condition('systemdisabled', TRUE, '<>');
    }
 
    if ($includeHidden === FALSE) {
      // An empty field is also FALSE, so we have to test for !TRUE.
      $select->condition('systemhidden', TRUE, '<>');
    }
 
    // Process names into an array where keys are names and values are IDs.
    $names = [];
    foreach ($select->execute() as $result) {
      $names[$result->name] = (int) $result->id;
    }
 
    return $names;
  }
 
  /**
   * {@inheritdoc}
   */
  public function findChildren(
    bool $includeDisabled = TRUE,
    bool $includeHidden = FALSE) {
 
    if ($this->isFolder() === FALSE) {
      return [];
    }
 
    return self::loadMultiple($this->findChildrenIds(
      $includeDisabled,
      $includeHidden));
  }
 
  /**
   * {@inheritdoc}
   */
  public function findChildrenNumberOfBytes() {
 
    $connection = Database::getConnection();
    $select = $connection->select(self::BASE_TABLE, 'fs');
    $select->condition('fs.parentid', $this->id(), '=');
 
    // An empty field is also FALSE, so we have to test for !TRUE.
    $select->condition('fs.systemhidden', TRUE, '<>');
 
    $select->addExpression('SUM(fs.size)', 'size');
 
    return (int) $select->execute()->fetchField();
  }
 
  /**
   * {@inheritdoc}
   */
  public function findNumberOfChildren(
    bool $includeDisabled = TRUE,
    bool $includeHidden = FALSE) {
 
    if ($this->isFolder() === FALSE) {
      return 0;
    }
 
    $connection = Database::getConnection();
    $select = $connection->select(self::BASE_TABLE, 'fs');
    $select->addField('fs', 'id', 'id');
    $select->condition('parentid', $this->id(), '=');
 
    if ($includeDisabled === FALSE) {
      // An empty field is also FALSE, so we have to test for !TRUE.
      $select->condition('systemdisabled', TRUE, '<>');
    }
 
    if ($includeHidden === FALSE) {
      // An empty field is also FALSE, so we have to test for !TRUE.
      $select->condition('systemhidden', TRUE, '<>');
    }
 
    return (int) $select->countQuery()->execute()->fetchField();
  }
 
  /*---------------------------------------------------------------------
   *
   * Find children that are files.
   *
   *---------------------------------------------------------------------*/
 
  /**
   * {@inheritdoc}
   */
  public function findFileChildrenIds(
    bool $includeDisabled = TRUE,
    bool $includeHidden = FALSE) {
 
    $connection = Database::getConnection();
    $select = $connection->select(self::BASE_TABLE, 'fs');
    $select->addField('fs', 'id', 'id');
    $select->condition('parentid', $this->id(), '=');
 
    if ($includeDisabled === FALSE) {
      // An empty field is also FALSE, so we have to test for !TRUE.
      $select->condition('systemdisabled', TRUE, '<>');
    }
 
    if ($includeHidden === FALSE) {
      // An empty field is also FALSE, so we have to test for !TRUE.
      $select->condition('systemhidden', TRUE, '<>');
    }
 
    $group = $select->orConditionGroup()
      ->condition('kind', self::FILE_KIND, '=')
      ->condition('kind', self::IMAGE_KIND, '=')
      ->condition('kind', self::MEDIA_KIND, '=');
    $select = $select->condition($group);
 
    return $select->execute()->fetchCol(0);
  }
 
  /**
   * {@inheritdoc}
   */
  public function findFileChildren(
    bool $includeDisabled = TRUE,
    bool $includeHidden = FALSE) {
 
    return self::loadMultiple($this->findFileChildrenIds(
      $includeDisabled,
      $includeHidden));
  }
 
  /*---------------------------------------------------------------------
   *
   * Find children that are folders.
   *
   *---------------------------------------------------------------------*/
 
  /**
   * {@inheritdoc}
   */
  public function findFolderChildrenIds(
    bool $includeDisabled = TRUE,
    bool $includeHidden = FALSE) {
 
    // Query all folders that list this folder as a parent.
    $select = \Drupal::entityQuery(self::ENTITY_TYPE_ID)
      ->condition('kind', self::FOLDER_KIND, '=')
      ->condition('parentid', $this->id(), '=');
 
    if ($includeDisabled === FALSE) {
      // An empty field is also FALSE, so we have to test for !TRUE.
      $select->condition('systemdisabled', TRUE, '<>');
    }
 
    if ($includeHidden === FALSE) {
      // An empty field is also FALSE, so we have to test for !TRUE.
      $select->condition('systemhidden', TRUE, '<>');
    }
 
    return $select->execute();
  }
 
  /**
   * {@inheritdoc}
   */
  public function findFolderChildren(
    bool $includeDisabled = TRUE,
    bool $includeHidden = FALSE) {
 
    return self::loadMultiple($this->findFolderChildrenIds(
      $includeDisabled,
      $includeHidden));
  }
 
  /*---------------------------------------------------------------------
   *
   * Find ancestors.
   *
   *---------------------------------------------------------------------*/
 
  /**
   * {@inheritdoc}
   */
  public function findAncestorFolderIds() {
 
    // If this is a root item, it has no parent and thus no ancestors.
    $parentId = $this->getParentFolderId();
    if ($parentId === self::USER_ROOT_LIST) {
      return [];
    }
 
    $ancestorIds = [$parentId];
    $connection = Database::getConnection();
 
    // Repeatedly query to get each ancestor, saving their IDs.
    while (TRUE) {
      $select = $connection->select(self::BASE_TABLE, 'fs');
      $select->addField('fs', 'parentid', 'parentid');
      $select->condition('id', $parentId, '=');
      $results = $select->execute()->fetchAll();
 
      if (empty($results) === TRUE) {
        break;
      }
 
      $parentId = (int) $results[0]->parentid;
      $ancestorIds[] = $parentId;
    }
 
    // Reverse so that the list is root first.
    return array_reverse($ancestorIds);
  }
 
  /**
   * {@inheritdoc}
   */
  public function findAncestorFolderNames() {
    // If this is a root item, it has no parent and thus no ancestors.
    $parentId = $this->getParentFolderId();
    if ($parentId === self::USER_ROOT_LIST) {
      return [];
    }
 
    $connection = Database::getConnection();
    $ancestorNames = [];
 
    // Repeatedly query to get each ancestor, saving their IDs.
    while ($parentId !== self::USER_ROOT_LIST) {
      $select = $connection->select(self::BASE_TABLE, 'fs');
      $select->addField('fs', 'parentid', 'parentid');
      $select->addField('fs', 'name', 'name');
      $select->condition('id', $parentId, '=');
      $results = $select->execute()->fetchAll();
 
      if (empty($results) === TRUE) {
        break;
      }
 
      $parentId = (int) $results[0]->parentid;
      $ancestorNames[] = $results[0]->name;
    }
 
    // Reverse so that the list is root first.
    return array_reverse($ancestorNames);
  }
 
  /**
   * {@inheritdoc}
   */
  public function findAncestorFolders() {
    return self::loadMultiple($this->findAncestorFolderIds());
  }
 
  /**
   * {@inheritdoc}
   */
  public function isAncestorOfFolderId(int $folderId) {
    if ($folderId < 0) {
      return FALSE;
    }
 
    $folder = self::load($folderId);
    if ($folder === NULL) {
      return FALSE;
    }
 
    // This folder is an ancestor of the given folder if that folder's
    // list of ancestor folder IDs contains this folder's ID.
    return in_array((int) $this->id(), $folder->findAncestorFolderIds());
  }
 
  /*---------------------------------------------------------------------
   *
   * Find descendants.
   *
   *---------------------------------------------------------------------*/
 
  /**
   * {@inheritdoc}
   */
  public function findDescendantIds(
    bool $includeDisabled = TRUE,
    bool $includeHidden = FALSE) {
 
    // If this is not a folder, there are no descendants.
    if ($this->isFolder() === FALSE) {
      return [];
    }
 
    $connection  = Database::getConnection();
    $startingId  = (int) $this->id();
    $pending     = [$startingId];
    $descendants = [];
 
    while (empty($pending) === FALSE) {
      // Get the next pending ID.
      $id = array_shift($pending);
 
      // Add it to the descendant list, if it isn't the starting ID.
      if ($id !== $startingId) {
        $descendants[] = $id;
      }
 
      // Get non-folder children and add them to the descendants list.
      $select = $connection->select(self::BASE_TABLE, 'fs');
      $select->addField('fs', 'id', 'id');
      $select->condition('parentid', $id, '=');
      $select->condition('kind', self::FOLDER_KIND, '<>');
 
      if ($includeDisabled === FALSE) {
        // An empty field is also FALSE, so we have to test for !TRUE.
        $select->condition('systemdisabled', TRUE, '<>');
      }
 
      if ($includeHidden === FALSE) {
        // An empty field is also FALSE, so we have to test for !TRUE.
        $select->condition('systemhidden', TRUE, '<>');
      }
 
      $descendants = array_merge($descendants, $select->execute()->fetchCol(0));
 
      // Get folder children and add them to the pending list.
      $select = $connection->select(self::BASE_TABLE, 'fs');
      $select->addField('fs', 'id', 'id');
      $select->condition('parentid', $id, '=');
      $select->condition('kind', self::FOLDER_KIND, '=');
 
      if ($includeDisabled === FALSE) {
        // An empty field is also FALSE, so we have to test for !TRUE.
        $select->condition('systemdisabled', TRUE, '<>');
      }
 
      if ($includeHidden === FALSE) {
        // An empty field is also FALSE, so we have to test for !TRUE.
        $select->condition('systemhidden', TRUE, '<>');
      }
 
      $pending = array_merge($pending, $select->execute()->fetchCol(0));
    }
 
    return $descendants;
  }
 
  /**
   * {@inheritdoc}
   */
  public function findDescendantIdsByOwnerId(
    int $ownerUid = self::ANY_USER_ID,
    bool $match = TRUE) {
 
    // If this is not a folder, there are no descendants.
    if ($this->isFolder() === FALSE) {
      return [];
    }
 
    $connection  = Database::getConnection();
    $startingId  = (int) $this->id();
    $pending     = [$startingId];
    $descendants = [];
    $matchOp     = ($match === TRUE) ? '=' : '<>';
 
    while (empty($pending) === FALSE) {
      // Get the next pending ID.
      $id = array_shift($pending);
 
      // Get non-folder children that match the owner ID criteria (if any)
      // and add them to the descendants list.
      $select = $connection->select(self::BASE_TABLE, 'fs');
      $select->addField('fs', 'id', 'id');
      $select->condition('parentid', $id, '=');
      $select->condition('kind', self::FOLDER_KIND, '<>');
      if ($ownerUid !== self::ANY_USER_ID) {
        $select->condition('uid', $ownerUid, $matchOp);
      }
 
      $descendants = array_merge($descendants, $select->execute()->fetchCol(0));
 
      // A folder child could have a matching owner ID, while its children
      // do not. First query to get ALL folder children and add them to
      // the pending list. Then query to get only those folder children
      // that match the owner ID criteria (if any) and add them to the
      // descendants list.
      $select = $connection->select(self::BASE_TABLE, 'fs');
      $select->addField('fs', 'id', 'id');
      $select->condition('parentid', $id, '=');
      $select->condition('kind', self::FOLDER_KIND, '=');
 
      $allFolderChildren = $select->execute()->fetchCol(0);
      $pending = array_merge($pending, $allFolderChildren);
 
      if ($ownerUid === self::ANY_USER_ID) {
        // All folder children added to the pending list are also relevant
        // descendants to return.
        $descendants = array_merge($descendants, $allFolderChildren);
      }
      else {
        // Only folder children that match the owner ID criteria should be
        // added to the descendants list.
        $select = $connection->select(self::BASE_TABLE, 'fs');
        $select->addField('fs', 'id', 'id');
        $select->condition('parentid', $id, '=');
        $select->condition('kind', self::FOLDER_KIND, '=');
        $select->condition('uid', $ownerUid, $matchOp);
 
        $matchingFolderChildren = $select->execute()->fetchCol(0);
        $descendants = array_merge($descendants, $matchingFolderChildren);
      }
    }
 
    return $descendants;
  }
 
  /**
   * {@inheritdoc}
   */
  public function findDescendantIdsByRootId(
    int $rootId = self::ANY_ITEM_ID,
    bool $match = TRUE) {
 
    // If this is not a folder, there are no descendants.
    if ($this->isFolder() === FALSE) {
      return [];
    }
 
    $connection  = Database::getConnection();
    $startingId  = (int) $this->id();
    $pending     = [$startingId];
    $descendants = [];
    $matchOp     = ($match === TRUE) ? '=' : '<>';
 
    while (empty($pending) === FALSE) {
      // Get the next pending ID.
      $id = (int) array_shift($pending);
 
      // Get non-folder children that match the root ID criteria (if any)
      // and add them to the descendants list.
      $select = $connection->select(self::BASE_TABLE, 'fs');
      $select->addField('fs', 'id', 'id');
      $select->condition('parentid', $id, '=');
      $select->condition('kind', self::FOLDER_KIND, '<>');
      if ($rootId !== self::ANY_ITEM_ID) {
        $select->condition('rootid', $rootId, $matchOp);
      }
 
      $descendants = array_merge($descendants, $select->execute()->fetchCol(0));
 
      // A folder child could have a matching root ID, while its children
      // do not. First query to get ALL folder children and add them to
      // the pending list. Then query to get only those folder children
      // that match the root ID criteria (if any) and add them to the
      // descendants list.
      $select = $connection->select(self::BASE_TABLE, 'fs');
      $select->addField('fs', 'id', 'id');
      $select->condition('parentid', $id, '=');
      $select->condition('kind', self::FOLDER_KIND, '=');
 
      $allFolderChildren = $select->execute()->fetchCol(0);
      $pending = array_merge($pending, $allFolderChildren);
 
      if ($rootId === self::ANY_ITEM_ID) {
        // All folder children added to the pending list are also relevant
        // descendants to return.
        $descendants = array_merge($descendants, $allFolderChildren);
      }
      else {
        // Only folder children that match the root ID criteria should be
        // added to the descendants list.
        $select = $connection->select(self::BASE_TABLE, 'fs');
        $select->addField('fs', 'id', 'id');
        $select->condition('parentid', $id, '=');
        $select->condition('kind', self::FOLDER_KIND, '=');
        $select->condition('rootid', $rootId, $matchOp);
 
        $matchingFolderChildren = $select->execute()->fetchCol(0);
        $descendants = array_merge($descendants, $matchingFolderChildren);
      }
    }
 
    return $descendants;
  }
 
  /**
   * {@inheritdoc}
   */
  public function isDescendantOfFolderId(int $proposedAncestorId) {
    // There are two ways to implement this:
    //
    // - Get a list of all descendant IDs of the proposed ancestor,
    //   then see if this entity's ID is in that list.
    //
    // - Get a list of all ancestor IDs of this entity, then see if
    //   the proposed ancestor is one of those.
    //
    // The second implementation looks up the folder tree and is much
    // faster than the first implementation, which looks down through
    // the folder tree.
    return in_array($proposedAncestorId, $this->findAncestorFolderIds());
  }
 
  /*---------------------------------------------------------------------
   *
   * Find kinds.
   *
   *---------------------------------------------------------------------*/
 
  /**
   * Finds the kind for each of the given entity IDs.
   *
   * The returned associative array has one key for each FolderShare
   * entity kind present in the ID list. The associated value is an array
   * of integer entity IDs for items of that kind from the ID list.
   * Invalid IDs are silently ignored and will not be included in the
   * returned array.
   *
   * @param int[] $ids
   *   An array of integer FolderShare entity IDs for entities to look up.
   *
   * @return array
   *   Returns an associative array with FolderShare kinds as keys, and
   *   an array of IDs for each kind. If a kind is not present in the
   *   array, then no entity IDs of that kind were found.
   */
  public static function findKindsForIds(array $ids) {
    if (empty($ids) === TRUE) {
      return [];
    }
 
    $connection = Database::getConnection();
    $query = $connection->select(self::BASE_TABLE, 'fs');
    $query->addField('fs', 'id', 'id');
    $query->addField('fs', 'kind', 'kind');
    $query->condition('id', $ids, 'IN');
 
    $ordered = [];
    foreach ($query->execute() as $result) {
      $ordered[$result->kind][] = (int) $result->id;
    }
 
    return $ordered;
  }
 
  /*---------------------------------------------------------------------
   *
   * Find flagged.
   *
   *---------------------------------------------------------------------*/
 
  /**
   * Returns a list of item IDs that are hidden.
   *
   * @return int[]
   *   An unordered list of integer entity IDs for hidden items.
   *
   * @see ::findAllIds()
   */
  public static function findAllHiddenIds() {
 
    $query = \Drupal::entityQuery(self::BASE_TABLE);
    $query->condition('systemhidden', TRUE, '=');
 
    $ids = [];
    foreach ($query->execute() as $result) {
      $ids[] = (int) $result;
    }
 
    return $ids;
  }
 
  /**
   * Returns the number of hidden items.
   *
   * @return int
   *   Returns the number of hidden items.
   *
   * @see ::findAllHiddenIds()
   */
  public static function countNumberOfHiddenItems() {
 
    $connection = Database::getConnection();
    $query = $connection->select(self::BASE_TABLE, 'fs');
    $query->condition('systemhidden', TRUE, '=');
 
    return (int) $query->countQuery()->execute()->fetchField();
  }
 
  /**
   * Returns a list of item IDs that are disabled.
   *
   * @return int[]
   *   An unordered list of integer entity IDs for disabled items.
   *
   * @see ::findAllIds()
   */
  public static function findAllDisabledIds() {
 
    $query = \Drupal::entityQuery(self::BASE_TABLE);
    $query->condition('systemdisabled', TRUE, '=');
 
    $ids = [];
    foreach ($query->execute() as $result) {
      $ids[] = (int) $result;
    }
 
    return $ids;
  }
 
  /**
   * Returns the number of disabled items.
   *
   * @return int
   *   Returns the number of disabled items.
   *
   * @see ::findAllHiddenIds()
   */
  public static function countNumberOfDisabledItems() {
 
    $connection = Database::getConnection();
    $query = $connection->select(self::BASE_TABLE, 'fs');
    $query->condition('systemdisabled', TRUE, '=');
 
    return (int) $query->countQuery()->execute()->fetchField();
  }
 
}
Главная | Обратная связь
You are here

foldershare-8.x-1.2/src/Entity/FolderShareTraits/FindTrait.php
