abstract class RestfulDataProviderDbQuery in RESTful 7

@file Contains \RestfulDataProviderDbQuery

Hierarchy

class \RestfulPluginBase implements RestfulPluginInterface
- class \RestfulBase implements RestfulInterface
  - class \RestfulDataProviderDbQuery implements RestfulDataProviderDbQueryInterface, RestfulDataProviderInterface

Expanded class hierarchy of RestfulDataProviderDbQuery

File

plugins/restful/RestfulDataProviderDbQuery.php, line 8: Contains \RestfulDataProviderDbQuery

View source

abstract class RestfulDataProviderDbQuery extends \RestfulBase implements \RestfulDataProviderDbQueryInterface, \RestfulDataProviderInterface {

  /**
   * The name of the table to query.
   *
   * @var string
   */
  protected $tableName;

  /**
   * The name of the column(s) in the table to be used as the unique key.
   *
   * @var array
   */
  protected $idColumn;

  /**
   * The separator used to divide a key into its table columns when there is
   * more than one column.
   */
  const COLUMN_IDS_SEPARATOR = '::';

  /**
   * Holds the primary field.
   *
   * @var string
   */
  protected $primary;

  /**
   * Get ID column
   *
   * @return array
   *   An array with the name of the column(s) in the table to be used as the
   *   unique key.
   */
  public function getIdColumn() {
    return is_array($this->idColumn) ? $this->idColumn : array(
      $this->idColumn,
    );
  }

  /**
   * Set the name of the column in the table to be used as the unique key.
   *
   * @param string $id_column
   *   The name of the column in the table to be used as the unique key.
   */
  public function setIdColumn($id_column) {
    $this->idColumn = $id_column;
  }

  /**
   * Get the name of the table to query.
   *
   * @return string
   *   The name of the table to query.
   */
  public function getTableName() {
    return $this->tableName;
  }

  /**
   * Set the name of the table to query.
   *
   * @param string $table_name
   *   The name of the table to query.
   */
  public function setTableName($table_name) {
    $this->tableName = $table_name;
  }

  /**
   * @return string
   **/
  public function getPrimary() {
    return $this->primary;
  }

  /**
   * @param string $primary
   **/
  public function setPrimary($primary) {
    $this->primary = $primary;
  }

  /**
   * Constructs a RestfulDataProviderDbQuery object.
   *
   * @param array $plugin
   *   Plugin definition.
   * @param RestfulAuthenticationManager $auth_manager
   *   (optional) Injected authentication manager.
   * @param DrupalCacheInterface $cache_controller
   *   (optional) Injected cache backend.
   * @param string $language
   *   (optional) The language to return items in.
   */
  public function __construct(array $plugin, \RestfulAuthenticationManager $auth_manager = NULL, \DrupalCacheInterface $cache_controller = NULL, $language = NULL) {
    parent::__construct($plugin, $auth_manager, $cache_controller, $language);

    // Validate keys exist in the plugin's "data provider options".
    $required_keys = array(
      'table_name',
      'id_column',
    );
    $options = $this
      ->processDataProviderOptions($required_keys);
    $this->tableName = $options['table_name'];
    $this->idColumn = $options['id_column'];
    $this->primary = empty($plugin['data_provider_options']['primary']) ? NULL : ($this->primary = $plugin['data_provider_options']['primary']);
  }

  /**
   * Defines default sort columns if none are provided via the request URL.
   *
   * @return array
   *   Array keyed by the database column name, and the order ('ASC' or 'DESC') as value.
   */
  public function defaultSortInfo() {
    $sorts = array();
    foreach ($this
      ->getIdColumn() as $column) {
      if (!empty($this->getPublicFields[$column])) {

        // Sort by the first ID column that is a public field.
        $sorts[$column] = 'ASC';
        break;
      }
    }
    return $sorts;
  }

  /**
   * Get a basic query object.
   *
   * @return SelectQuery
   *   A new SelectQuery object for this connection.
   */
  protected function getQuery() {
    $table = $this
      ->getTableName();
    return db_select($table)
      ->fields($table);
  }

  /**
   * {@inheritdoc}
   */
  public function getQueryForList() {
    $query = $this
      ->getQuery();
    $this
      ->queryForListSort($query);
    $this
      ->queryForListFilter($query);
    $this
      ->queryForListPagination($query);
    $this
      ->addExtraInfoToQuery($query);
    return $query;
  }

  /**
   * Sort the query for list.
   *
   * @param \SelectQuery $query
   *   The query object.
   *
   * @throws \RestfulBadRequestException
   *
   * @see \RestfulEntityBase::getQueryForList
   */
  protected function queryForListSort(\SelectQuery $query) {
    $public_fields = $this
      ->getPublicFields();

    // Get the sorting options from the request object.
    $sorts = $this
      ->parseRequestForListSort();
    $sorts = $sorts ? $sorts : $this
      ->defaultSortInfo();
    foreach ($sorts as $sort => $direction) {
      $column_name = $this
        ->getPropertyColumnForQuery($public_fields[$sort]);
      $query
        ->orderBy($column_name, $direction);
    }
  }

  /**
   * Filter the query for list.
   *
   * @param \SelectQuery $query
   *   The query object.
   *
   * @throws \RestfulBadRequestException
   *
   * @see \RestfulEntityBase::getQueryForList
   */
  protected function queryForListFilter(\SelectQuery $query) {
    $public_fields = $this
      ->getPublicFields();
    foreach ($this
      ->parseRequestForListFilter() as $filter) {
      if (in_array(strtoupper($filter['operator'][0]), array(
        'IN',
        'NOT IN',
        'BETWEEN',
      ))) {
        $column_name = $this
          ->getPropertyColumnForQuery($public_fields[$filter['public_field']]);
        if (is_array($filter['value']) && empty($filter['value'])) {
          if (strtoupper($filter['operator'][0]) == 'NOT IN') {

            // Skip filtering by an empty value when operator is 'NOT IN',
            // since it throws an SQL error.
            continue;
          }

          // Since Drupal doesn't know how to handle an empty array within a
          // condition we add the `NULL` as an element to the array.
          $filter['value'] = array(
            NULL,
          );
        }
        $query
          ->condition($column_name, $filter['value'], $filter['operator'][0]);
        continue;
      }
      $condition = db_condition($filter['conjunction']);
      for ($index = 0; $index < count($filter['value']); $index++) {
        $column_name = $this
          ->getPropertyColumnForQuery($public_fields[$filter['public_field']]);
        $condition
          ->condition($column_name, $filter['value'][$index], $filter['operator'][$index]);
      }
      $query
        ->condition($condition);
    }
  }

  /**
   * Set correct page (i.e. range) for the query for list.
   *
   * Determine the page that should be seen. Page 1, is actually offset 0 in the
   * query range.
   *
   * @param \SelectQuery $query
   *   The query object.
   *
   * @throws \RestfulBadRequestException
   *
   * @see \RestfulEntityBase::getQueryForList
   */
  protected function queryForListPagination(\SelectQuery $query) {
    list($range, $offset) = $this
      ->parseRequestForListPagination();
    $query
      ->range($range, $offset);
  }

  /**
   * Return the column name that should be used for query.
   *
   * As MySql prevents using the column alias on WHERE or ORDER BY, we give
   * implementers a chance to explicitly define the real coloumn for the query.
   *
   * @param $public_field_name
   *   The public field name.
   *
   * @return string
   *   The column name.
   */
  protected function getPropertyColumnForQuery($public_field_name) {
    $public_fields = $this
      ->getPublicFields();
    return !empty($public_fields[$public_field_name['property']]['column_for_query']) ? $public_fields[$public_field_name['property']]['column_for_query'] : $public_field_name['property'];
  }

  /**
   * {@inheritdoc}
   */
  protected function addDefaultValuesToPublicFields(array $public_fields = array()) {

    // Set defaults values.
    $public_fields = parent::addDefaultValuesToPublicFields($public_fields);
    foreach (array_keys($public_fields) as $key) {
      $info =& $public_fields[$key];
      $info += array(
        'column_for_query' => FALSE,
      );
    }
    return $public_fields;
  }

  /**
   * {@inheritdoc}
   */
  public function getQueryCount() {
    $table = $this
      ->getTableName();
    $query = $this
      ->getQuery();
    if ($path = $this
      ->getPath()) {
      $ids = explode(',', $path);
      if (!empty($ids)) {
        foreach ($this
          ->getIdColumn() as $index => $column) {
          $query
            ->condition($table . '.' . $column, $this
            ->getColumnFromIds($ids, $index), 'IN');
        }
      }
    }
    $this
      ->queryForListFilter($query);
    $this
      ->addExtraInfoToQuery($query);
    $query
      ->addTag('restful_count');
    return $query
      ->countQuery();
  }

  /**
   * {@inheritdoc}
   */
  public function getTotalCount() {
    return intval($this
      ->getQueryCount()
      ->execute()
      ->fetchField());
  }

  /**
   * Adds query tags and metadata to the EntityFieldQuery.
   *
   * @param \SelectQuery $query
   *   The query to enhance.
   */
  protected function addExtraInfoToQuery($query) {
    $query
      ->addTag('restful');
    $query
      ->addMetaData('account', $this
      ->getAccount());
    $query
      ->addMetaData('restful_handler', $this);
  }

  /**
   * {@inheritdoc}
   */
  public function index() {
    $results = $this
      ->getQueryForList()
      ->execute();
    $return = array();
    foreach ($results as $result) {
      $return[] = $this
        ->mapDbRowToPublicFields($result);
    }
    return $return;
  }

  /**
   * {@inheritdoc}
   */
  public function viewMultiple(array $ids) {
    $cache_id = array(
      'tb' => $this
        ->getTableName(),
      'cl' => implode(',', $this
        ->getIdColumn()),
      'id' => implode(',', $ids),
    );
    $cached_data = $this
      ->getRenderedCache($cache_id);
    if (!empty($cached_data->data)) {
      return $cached_data->data;
    }

    // Get a list query with all the sorting and pagination in place.
    $query = $this
      ->getQueryForList();
    if (empty($ids)) {
      return array();
    }
    foreach ($this
      ->getIdColumn() as $index => $column) {
      $query
        ->condition($this
        ->getTableName() . '.' . $column, $this
        ->getColumnFromIds($ids, $index), 'IN');
    }
    $results = $query
      ->execute();
    $return = array();
    foreach ($results as $result) {
      $return[] = $this
        ->mapDbRowToPublicFields($result);
    }
    $this
      ->setRenderedCache($return, $cache_id);
    return $return;
  }

  /**
   * {@inheritdoc}
   */
  public function view($ids) {
    return $this
      ->viewMultiple(explode(',', $ids));
  }

  /**
   * Replace a record by another.
   */
  protected function replace($id) {
    return $this
      ->update($id, TRUE);
  }

  /**
   * {@inheritdoc}
   */
  public function update($id, $full_replace = FALSE) {

    // Build the update array.
    $request = $this
      ->getRequest();
    static::cleanRequest($request);
    $save = FALSE;
    $original_request = $request;
    $public_fields = $this
      ->getPublicFields();
    $id_columns = $this
      ->getIdColumn();
    $record = array();
    foreach ($public_fields as $public_field_name => $info) {

      // Ignore passthrough public fields.
      if (!empty($info['create_or_update_passthrough'])) {
        unset($original_request[$public_field_name]);
        continue;
      }

      // If this is the primary field, skip.
      if ($this
        ->isPrimaryField($info['property'])) {
        continue;
      }
      if (isset($request[$public_field_name])) {
        $record[$info['property']] = $request[$public_field_name];
      }
      elseif ($full_replace) {
        $record[$info['property']] = NULL;
      }
      unset($original_request[$public_field_name]);
      $save = TRUE;
    }

    // No request was sent.
    if (!$save) {
      throw new \RestfulBadRequestException('No values were sent with the request.');
    }

    // If the original request is not empty, then illegal values are present.
    if (!empty($original_request)) {
      $error_message = format_plural(count($original_request), 'Property @names is invalid.', 'Property @names are invalid.', array(
        '@names' => implode(', ', array_keys($original_request)),
      ));
      throw new \RestfulBadRequestException($error_message);
    }

    // Add the id column values into the record.
    foreach ($this
      ->getIdColumn() as $index => $column) {
      $record[$column] = current($this
        ->getColumnFromIds(array(
        $id,
      ), $index));
    }

    // Once the record is built, write it.
    if (!drupal_write_record($this
      ->getTableName(), $record, $id_columns)) {
      throw new \RestfulServiceUnavailable('Record could not be updated to the database.');
    }

    // Clear the rendered cache before calling the view method.
    $this
      ->clearRenderedCache(array(
      'tb' => $this
        ->getTableName(),
      'cl' => implode(',', $this
        ->getIdColumn()),
      'id' => $id,
    ));
    return $this
      ->view($id);
  }

  /**
   * {@inheritdoc}
   */
  public function create() {
    $request = $this
      ->getRequest();
    static::cleanRequest($request);
    $save = FALSE;
    $original_request = $request;
    $public_fields = $this
      ->getPublicFields();
    $id_columns = $this
      ->getIdColumn();
    $record = array();
    foreach ($public_fields as $public_field_name => $info) {

      // Ignore passthrough public fields.
      if (!empty($info['create_or_update_passthrough'])) {
        unset($original_request[$public_field_name]);
        continue;
      }

      // If this is the primary field, skip.
      if ($this
        ->isPrimaryField($info['property'])) {
        unset($original_request[$public_field_name]);
        continue;
      }
      if (isset($request[$public_field_name])) {
        $record[$info['property']] = $request[$public_field_name];
      }
      unset($original_request[$public_field_name]);
      $save = TRUE;
    }

    // No request was sent.
    if (!$save) {
      throw new \RestfulBadRequestException('No values were sent with the request.');
    }

    // If the original request is not empty, then illegal values are present.
    if (!empty($original_request)) {
      $error_message = format_plural(count($original_request), 'Property @names is invalid.', 'Property @names are invalid.', array(
        '@names' => implode(', ', array_keys($original_request)),
      ));
      throw new \RestfulBadRequestException($error_message);
    }

    // Once the record is built, write it and view it.
    if (drupal_write_record($this
      ->getTableName(), $record)) {

      // Handle multiple id columns.
      $id_values = array();
      foreach ($id_columns as $id_column) {
        $id_values[$id_column] = $record[$id_column];
      }
      $id = implode(self::COLUMN_IDS_SEPARATOR, $id_values);
      return $this
        ->view($id);
    }
    return;
  }

  /**
   * {@inheritdoc}
   */
  public function remove($id) {

    // If it's a delete method we will want a 204 response code.
    // Set the HTTP headers.
    $this
      ->setHttpHeaders('Status', 204);
    $query = db_delete($this
      ->getTableName());
    foreach ($this
      ->getIdColumn() as $index => $column) {
      $query
        ->condition($column, current($this
        ->getColumnFromIds(array(
        $id,
      ), $index)));
    }
    $query
      ->execute();
  }

  /**
   * {@inheritdoc}
   */
  public function mapDbRowToPublicFields($row) {
    if ($this
      ->getMethod() == \RestfulInterface::GET) {

      // For read operations cache the result.
      $output = $this->staticCache
        ->get(__CLASS__ . '::' . __FUNCTION__ . '::' . $this
        ->getUniqueId($row));
      if (isset($output)) {
        return $output;
      }
    }
    else {

      // Clear the cache if the request is not GET.
      $this->staticCache
        ->clear(__CLASS__ . '::' . __FUNCTION__ . '::' . $this
        ->getUniqueId($row));
    }
    $output = array();

    // Loop over all the defined public fields.
    foreach ($this
      ->getPublicFields() as $public_field_name => $info) {
      $value = NULL;
      if ($info['create_or_update_passthrough']) {

        // The public field is a dummy one, meant only for passing data upon
        // create or update.
        continue;
      }

      // If there is a callback defined execute it instead of a direct mapping.
      if ($info['callback']) {
        $value = static::executeCallback($info['callback'], array(
          $row,
        ));
      }
      elseif ($info['property']) {
        $value = $row->{$info['property']};
      }

      // Execute the process callbacks.
      if (isset($value) && $info['process_callbacks']) {
        foreach ($info['process_callbacks'] as $process_callback) {
          $value = static::executeCallback($process_callback, array(
            $value,
          ));
        }
      }
      $output[$public_field_name] = $value;
    }
    return $output;
  }

  /**
   * Returns a unique id for a table record.
   *
   * @param object $row
   *   The database record.
   *
   * @return string
   *   The ID
   */
  public function getUniqueId($row) {
    $keys = array(
      $this
        ->getTableName(),
    );
    foreach ($this
      ->getIdColumn() as $column) {
      $keys[] = $row->{$column};
    }
    return implode(self::COLUMN_IDS_SEPARATOR, $keys);
  }

  /**
   * Checks if the current field is the primary field.
   *
   * @param string $field
   *   The column name to check.
   *
   * @return boolean
   *   TRUE if it is the primary field, FALSE otherwise.
   */
  function isPrimaryField($field) {
    return $this->primary == $field;
  }

  /**
   * Given an array of string ID's return a single column. for example:
   *
   * Strings are divided by the delimiter self::COLUMN_IDS_SEPARATOR.
   *
   * @param array $ids
   *   An array of object IDs.
   * @param int $column
   *   0-N Zero indexed
   *
   * @return Array
   *   Returns an array at index $column
   */
  protected function getColumnFromIds(array $ids, $column = 0) {

    // Get a single column.
    return array_map(function ($id) use ($column) {
      $parts = explode(RestfulDataProviderDbQuery::COLUMN_IDS_SEPARATOR, $id);
      if (!isset($parts[$column])) {
        throw new \RestfulServerConfigurationException('Invalid ID provided.');
      }
      return $parts[$column];
    }, $ids);
  }

}

Members

Name	Modifiers	Type	Description	Overrides
RestfulBase::$authenticationManager	protected	property	Authentication manager.
RestfulBase::$cacheController	protected	property	Cache controller object.
RestfulBase::$controllers	protected	property	Nested array that provides information about what method to call for each route pattern.
RestfulBase::$httpHeaders	protected	property	Array keyed by the header property, and the value.
RestfulBase::$langcode	protected	property	Determines the language of the items that should be returned.
RestfulBase::$method	protected	property	The HTTP method used for the request.
RestfulBase::$path	protected	property	The path of the request.
RestfulBase::$publicFields	protected	property	The public fields that are exposed to the API.	1
RestfulBase::$range	protected	property	Determines the number of items that should be returned when viewing lists.
RestfulBase::$rateLimitManager	protected	property	Rate limit manager.
RestfulBase::$request	protected	property	The request array.
RestfulBase::$staticCache	public	property	Static cache controller.
RestfulBase::$valueMetadata	protected	property	Holds additional information about the generated values. This information is available to the formatters.
RestfulBase::access	public	function	Determine if user can access the handler. Overrides RestfulInterface::access	4
RestfulBase::accessByAllowOrigin	protected	function	Checks access based on the referer header and the allow_origin setting.
RestfulBase::addCidParams	protected static	function	Get the cache id parameters based on the keys.
RestfulBase::addHttpHeaders	public	function	Add the a value to a multi-value HTTP header. Overrides RestfulInterface::addHttpHeaders
RestfulBase::cacheInvalidate	public	function	Invalidates cache for a certain entity.
RestfulBase::cleanRequest	public static	function	Helper function to remove the application generated request data.
RestfulBase::clearRenderedCache	protected	function	Clear an entry from the rendered cache.
RestfulBase::clearResourceRenderedCache	public	function	Clear all caches corresponding to the current resource.
RestfulBase::controllersInfo	public static	function	Returns the default controllers for the entity.	1
RestfulBase::delete	public	function	Call resource using the DELETE http method.
RestfulBase::executeCallback	public static	function	Execute a user callback.
RestfulBase::format	public	function	Call the output format on the given data.
RestfulBase::formatter	protected	function	Get the formatter handler for the current restful formatter.
RestfulBase::formatterNames	public	function	Returns the names of the available formatter plugins.
RestfulBase::generateCacheId	protected	function	Generate a cache identifier for the request and the current context.
RestfulBase::get	public	function	Call resource using the GET http method.
RestfulBase::getAccount	public	function	Proxy method to get the account from the authenticationManager.
RestfulBase::getAuthenticationManager	public	function	Getter for $authenticationManager.
RestfulBase::getCacheController	public	function	Getter for $cacheController.
RestfulBase::getControllerFromPath	public	function	Return the controller from a given path.
RestfulBase::getControllers	public	function	Get the defined controllers
RestfulBase::getHttpHeaders	public	function	Return array keyed by the header property, and the value. Overrides RestfulInterface::getHttpHeaders
RestfulBase::getLangCode	public	function	Get the language code.
RestfulBase::getMenuItem	public static	function	Get the non translated menu item.
RestfulBase::getMethod	public	function	Get the HTTP method used for the request.
RestfulBase::getPageArguments	public static	function	Get the resource name and version from the page arguments in the router.
RestfulBase::getPath	public	function	Return the path of the request.
RestfulBase::getPublicFields	public	function	Return the properties that should be public after processing. Overrides RestfulInterface::getPublicFields
RestfulBase::getRange	public	function	Get the pager range.
RestfulBase::getRateLimitManager	public	function	Getter for rateLimitManager.
RestfulBase::getRenderedCache	protected	function	Get an entry from the rendered cache.
RestfulBase::getRequest	public	function	Get the request array.
RestfulBase::getRequestForSubRequest	protected	function	Gets a request array with the data that should be piped to sub requests.
RestfulBase::getResourceLastVersion	public static	function	Return the last version for a given resource.
RestfulBase::getResourceName	public	function	Return the resource name.
RestfulBase::getUrl	public	function	Helper method; Get the URL of the resource and query strings.
RestfulBase::getValueMetadata	public	function	Get value metadata.
RestfulBase::getVersion	public	function	Return array keyed with the major and minor version of the resource.
RestfulBase::getVersionFromRequest	public static	function	Gets the major and minor version for the current request.
RestfulBase::head	public	function	Call resource using the GET http method.
RestfulBase::isArrayNumeric	final public static	function	Helper method to determine if an array is numeric.
RestfulBase::isListRequest	public	function	Helper method to know if the current request is for a list.
RestfulBase::isReadMethod	public static	function	Determines if the HTTP method represents a read operation.
RestfulBase::isValidConjunctionForFilter	protected static	function	Check if a conjunction is valid for filtering.	2
RestfulBase::isValidMethod	public static	function	Determines if the HTTP method is one of the known methods.
RestfulBase::isValidOperatorsForFilter	protected static	function	Check if an operator is valid for filtering.	1
RestfulBase::isWriteMethod	public static	function	Determines if the HTTP method represents a write operation.
RestfulBase::newCacheObject	protected	function	Get the default cache object based on the plugin configuration.
RestfulBase::notImplementedCrudOperation	protected static	function	Helper method with the code to run for non implemented CRUD operations.
RestfulBase::options	public	function	Call resource using the OPTIONS http method.
RestfulBase::overrideRange	protected	function	Overrides the range parameter with the URL value if any.
RestfulBase::parseRequestForListFilter	protected	function	Filter the query for list.
RestfulBase::parseRequestForListPagination	protected	function	Parses the request object to get the pagination options.
RestfulBase::parseRequestForListSort	protected	function	Parses the request to get the sorting options.
RestfulBase::parseVersionString	public static	function	Parses the version string.
RestfulBase::patch	public	function	Call resource using the PATCH http method.
RestfulBase::post	public	function	Call resource using the POST http method.
RestfulBase::process	public	function	Entry point to process a request. Overrides RestfulInterface::process
RestfulBase::processDataProviderOptions	protected	function	Process plugin options by validation keys exists, and set default values.
RestfulBase::put	public	function	Call resource using the PUT http method.
RestfulBase::setAccount	public	function	Proxy method to set the account from the authenticationManager.
RestfulBase::setAuthenticationManager	public	function	Setter for $authenticationManager.
RestfulBase::setHttpHeaders	public	function	Set the HTTP headers. Overrides RestfulInterface::setHttpHeaders
RestfulBase::setLangCode	public	function	Sets the language code.
RestfulBase::setMethod	public	function	Set the HTTP method used for the request.
RestfulBase::setPath	public	function	Set the path of the request.
RestfulBase::setPublicFields	public	function	Set the public fields.
RestfulBase::setRange	public	function	Set the pager range.
RestfulBase::setRateLimitManager	public	function	Setter for rateLimitManager.
RestfulBase::setRenderedCache	protected	function	Store an entry in the rendered cache.
RestfulBase::setRequest	public	function	Set the request array.
RestfulBase::versionedUrl	public	function	Gets a resource URL based on the current version.
RestfulDataProviderDbQuery::$idColumn	protected	property	The name of the column(s) in the table to be used as the unique key.
RestfulDataProviderDbQuery::$primary	protected	property	Holds the primary field.
RestfulDataProviderDbQuery::$tableName	protected	property	The name of the table to query.
RestfulDataProviderDbQuery::addDefaultValuesToPublicFields	protected	function	Add default values to the public fields array. Overrides RestfulBase::addDefaultValuesToPublicFields
RestfulDataProviderDbQuery::addExtraInfoToQuery	protected	function	Adds query tags and metadata to the EntityFieldQuery. Overrides RestfulBase::addExtraInfoToQuery
RestfulDataProviderDbQuery::COLUMN_IDS_SEPARATOR		constant	The separator used to divide a key into its table columns when there is more than one column.
RestfulDataProviderDbQuery::create	public	function	Create an item from the request object. Overrides RestfulBase::create
RestfulDataProviderDbQuery::defaultSortInfo	public	function	Defines default sort columns if none are provided via the request URL.
RestfulDataProviderDbQuery::getColumnFromIds	protected	function	Given an array of string ID's return a single column. for example:
RestfulDataProviderDbQuery::getIdColumn	public	function	Get ID column
RestfulDataProviderDbQuery::getPrimary	public	function
RestfulDataProviderDbQuery::getPropertyColumnForQuery	protected	function	Return the column name that should be used for query.
RestfulDataProviderDbQuery::getQuery	protected	function	Get a basic query object.	1
RestfulDataProviderDbQuery::getQueryCount	public	function	Prepare a query for RestfulEntityBase::getTotalCount(). Overrides RestfulDataProviderDbQueryInterface::getQueryCount
RestfulDataProviderDbQuery::getQueryForList	public	function	Prepare a query for RestfulEntityBase::getList(). Overrides RestfulDataProviderDbQueryInterface::getQueryForList
RestfulDataProviderDbQuery::getTableName	public	function	Get the name of the table to query.
RestfulDataProviderDbQuery::getTotalCount	public	function	Helper method to get the total count of entities that match certain request. Overrides RestfulDataProviderDbQueryInterface::getTotalCount
RestfulDataProviderDbQuery::getUniqueId	public	function	Returns a unique id for a table record.
RestfulDataProviderDbQuery::index	public	function	Get a list of entities. Overrides RestfulBase::index
RestfulDataProviderDbQuery::isPrimaryField		function	Checks if the current field is the primary field.
RestfulDataProviderDbQuery::mapDbRowToPublicFields	public	function	Prepares the output array from the database row object. Overrides RestfulDataProviderDbQueryInterface::mapDbRowToPublicFields
RestfulDataProviderDbQuery::queryForListFilter	protected	function	Filter the query for list.
RestfulDataProviderDbQuery::queryForListPagination	protected	function	Set correct page (i.e. range) for the query for list.
RestfulDataProviderDbQuery::queryForListSort	protected	function	Sort the query for list.
RestfulDataProviderDbQuery::remove	public	function	Remove the item from the data source. Overrides RestfulBase::remove
RestfulDataProviderDbQuery::replace	protected	function	Replace a record by another.
RestfulDataProviderDbQuery::setIdColumn	public	function	Set the name of the column in the table to be used as the unique key.
RestfulDataProviderDbQuery::setPrimary	public	function
RestfulDataProviderDbQuery::setTableName	public	function	Set the name of the table to query.
RestfulDataProviderDbQuery::update	public	function	Update an item based on the request object. Overrides RestfulBase::update
RestfulDataProviderDbQuery::view	public	function	View an item from the data source. Overrides RestfulBase::view
RestfulDataProviderDbQuery::viewMultiple	public	function	View a collection of items. Overrides RestfulBase::viewMultiple
RestfulDataProviderDbQuery::__construct	public	function	Constructs a RestfulDataProviderDbQuery object. Overrides RestfulBase::__construct
RestfulInterface::ACCESS_ALLOW		constant	Return this value from public field access callbacks to allow access.
RestfulInterface::ACCESS_DENY		constant	Return this value from public field access callbacks to deny access.
RestfulInterface::ACCESS_IGNORE		constant	Return this value from public field access callbacks to not affect access.
RestfulInterface::CONNECT		constant
RestfulInterface::DELETE		constant
RestfulInterface::GET		constant	HTTP methods.
RestfulInterface::HEAD		constant
RestfulInterface::OPTIONS		constant
RestfulInterface::PATCH		constant
RestfulInterface::POST		constant
RestfulInterface::publicFieldsInfo	public	function	Return the properties that should be public.	7
RestfulInterface::PUT		constant
RestfulInterface::TOKEN_VALUE		constant	Token value for token generation functions.
RestfulInterface::TRACE		constant
RestfulPluginBase::$plugin	protected	property	The plugin definition array.
RestfulPluginBase::getPlugin	public	function	Gets information about the restful plugin. Overrides RestfulPluginInterface::getPlugin
RestfulPluginBase::getPluginKey	public	function	Gets information about the restful plugin key. Overrides RestfulPluginInterface::getPluginKey
RestfulPluginBase::setPlugin	public	function	Sets information about the restful plugin. Overrides RestfulPluginInterface::setPlugin
RestfulPluginBase::setPluginKey	public	function	Gets information about the restful plugin key. Overrides RestfulPluginInterface::setPluginKey

You are here

abstract class RestfulDataProviderDbQuery in RESTful 7

Hierarchy

File

Members

API Navigation