/drupal7/sites/all/modules/views/includes/handlers.inc - Diff - Club Drupal - Forge Centrale Marseille

Révision 5d12d676

Ajouté par Assos Assos il y a environ 6 ans

ID 5d12d676de5cbb2a9d7fbb8077a554594a5c7f75
Parent f419e8de
Enfant ba3b3627

Weekly update of contrib modules

      */
     /**
      * Instantiate and construct a new handler
      * Instantiate and construct a new handler.
      */
     function _views_create_handler($definition, $type = 'handler', $handler_type = NULL) {
     //  debug('Instantiating handler ' . $definition['handler']);
       //  debug('Instantiating handler ' . $definition['handler']);
       if (empty($definition['handler'])) {
         vpr('_views_create_handler - type: @type - failed: handler has not been provided.',
           array('@type' => isset($handler_type) ? ( $type . '(handler type: ' . $handler_type . ')' ) : $type)
           array('@type' => isset($handler_type) ? ($type . '(handler type: ' . $handler_type . ')') : $type)
         );
         return;
+      }
-...
           '_views_create_handler - loading override handler @type failed: class @override_handler could not be loaded. ' .
           'Verify the class file has been registered in the corresponding .info-file (files[]).',
           array(
             '@type' => isset($handler_type) ? ( $type . '(handler type: ' . $handler_type . ')' ) : $type,
             '@override_handler' => $definition['override handler']
             '@type' => isset($handler_type) ? ($type . '(handler type: ' . $handler_type . ')') : $type,
             '@override_handler' => $definition['override handler'],
+          )
         );
         return;
-...
           '_views_create_handler - loading handler @type failed: class @handler could not be loaded. ' .
           'Verify the class file has been registered in the corresponding .info-file (files[]).',
           array(
             '@type' => isset($handler_type) ? ( $type . '(handler type: ' . $handler_type . ')' ) : $type,
             '@handler' => $definition['handler']
             '@type' => isset($handler_type) ? ($type . '(handler type: ' . $handler_type . ')') : $type,
             '@handler' => $definition['handler'],
+          )
         );
         return;
+      }
        if (!empty($definition['override handler'])) {
          $handler = new $definition['override handler'];
+       }
        else {
          $handler = new $definition['handler'];
+       }
       if (!empty($definition['override handler'])) {
         $handler = new $definition['override handler'];
+      }
       else {
         $handler = new $definition['handler'];
+      }
       $handler->set_definition($definition);
       if ($type == 'handler') {
-...
     function _views_prepare_handler($definition, $data, $field, $type) {
       foreach (array('group', 'title', 'title short', 'help', 'real field') as $key) {
         if (!isset($definition[$key])) {
           // First check the field level
           // First check the field level.
           if (!empty($data[$field][$key])) {
             $definition[$key] = $data[$field][$key];
+          }
           // Then if that doesn't work, check the table level
           // Then if that doesn't work, check the table level.
           elseif (!empty($data['table'][$key])) {
             $definition[$key] = $data['table'][$key];
+          }
-...
+    }
     /**
      * Fetch a handler to join one table to a primary table from the data cache
      * Fetch a handler to join one table to a primary table from the data cache.
      */
     function views_get_table_join($table, $base_table) {
       $data = views_fetch_data($table);
-...
           $handler = new views_join();
+        }
         // Fill in some easy defaults
         // Fill in some easy defaults.
         $handler->definition = $h;
         if (empty($handler->definition['table'])) {
           $handler->definition['table'] = $table;
-...
         return $handler;
+      }
       // DEBUG -- identify missing handlers
       // DEBUG -- identify missing handlers.
       vpr("Missing join: @table @base_table", array('@table' => $table, '@base_table' => $base_table));
+    }
-...
      *         field/handler is or does.
      * - access callback: If this field should have access control, this could
      *                    be a function to use. 'user_access' is a common
      *                    function to use here. If not specified, no access
      *                    public function to use here. If not specified, no access
      *                    control is provided.
      * - access arguments: An array of arguments for the access callback.
      */
     class views_handler extends views_object {
       /**
        * The top object of a view.
+       *
        * @var view
        */
       var $view = NULL;
       public $view = NULL;
       /**
        * Where the $query object will reside:
        * Where the $query object will reside:.
+       *
        * @var views_plugin_query
        */
       var $query = NULL;
       public $query = NULL;
       /**
        * The type of the handler, for example filter/footer/field.
        */
       var $handler_type = NULL;
       public $handler_type = NULL;
       /**
        * The alias of the table of this handler which is used in the query.
-...
        * The actual field in the database table, maybe different
        * on other kind of query plugins/special handlers.
        */
       var $real_field;
       public $real_field;
       /**
        * The relationship used for this field.
        */
       var $relationship = NULL;
       public $relationship = NULL;
       /**
        * init the handler with necessary data.
        * @param $view
        * Init the handler with necessary data.
+       *
        * @param view $view
        *   The $view object this handler is attached to.
        * @param $options
        * @param array $options
        *   The item from the database; the actual contents of this will vary
        *   based upon the type of handler.
        */
       function init(&$view, &$options) {
       public function init(&$view, &$options) {
         $this->view = &$view;
         $display_id = $this->view->current_display;
         // Check to see if this handler type is defaulted. Note that
         // we have to do a lookup because the type is singular but the
         // option is stored as the plural.
         // If the 'moved to' keyword moved our handler, let's fix that now.
         if (isset($this->actual_table)) {
           $options['table'] = $this->actual_table;
-...
           $display_id,
           $this->handler_type,
           $options['table'],
           $options['id']
           $options['id'],
         );
         $this->unpack_options($this->options, $options);
-...
         $this->query = &$view->query;
+      }
       function option_definition() {
       /**
        * {@inheritdoc}
        */
       public function option_definition() {
         $options = parent::option_definition();
         $options['id'] = array('default' => '');
-...
       /**
        * Return a string representing this handler's name in the UI.
        */
       function ui_name($short = FALSE) {
       public function ui_name($short = FALSE) {
         if (!empty($this->options['ui_name'])) {
           $title = check_plain($this->options['ui_name']);
           return $title;
-...
        * non-standard fields. Because this takes an argument, fields
        * overriding this can just call return parent::get_field($formula)
        */
       function get_field($field = NULL) {
       public function get_field($field = NULL) {
         if (!isset($field)) {
           if (!empty($this->formula)) {
             $field = $this->get_formula();
-...
+          }
+        }
         // If grouping, check to see if the aggregation method needs to modify the field.
         // If grouping, check to see if the aggregation method needs to modify the
         // field.
         if ($this->view->display_handler->use_group_by()) {
           $this->view->init_query();
           if ($this->query) {
-...
       /**
        * Sanitize the value for output.
+       *
        * @param $value
        * @param string $value
        *   The value being rendered.
        * @param $type
        * @param string $type
        *   The type of sanitization needed. If not provided, check_plain() is used.
+       *
        * @return string
        *   Returns the safe value.
        */
       function sanitize_value($value, $type = NULL) {
       public function sanitize_value($value, $type = NULL) {
         switch ($type) {
           case 'xss':
             $value = filter_xss($value);
             break;
           case 'xss_admin':
             $value = filter_xss_admin($value);
             break;
           case 'url':
             $value = check_url($value);
             break;
           default:
             $value = check_plain($value);
             break;
-...
       /**
        * Transform a string by a certain method.
+       *
        * @param $string
        * @param string $string
        *    The input you want to transform.
        * @param $option
        * @param array $option
        *    How do you want to transform it, possible values:
        *      - upper: Uppercase the string.
        *      - lower: lowercase the string.
-...
        * @return string
        *    The transformed string.
        */
       function case_transform($string, $option) {
       public function case_transform($string, $option) {
         global $multibyte;
         switch ($option) {
-...
             return $string;
           case 'upper':
             return drupal_strtoupper($string);
           case 'lower':
             return drupal_strtolower($string);
           case 'ucfirst':
             return drupal_strtoupper(drupal_substr($string, 0, 1)) . drupal_substr($string, 1);
           case 'ucwords':
             if ($multibyte == UNICODE_MULTIBYTE) {
               return mb_convert_case($string, MB_CASE_TITLE);
-...
       /**
        * Validate the options form.
        */
       function options_validate(&$form, &$form_state) { }
       public function options_validate(&$form, &$form_state) {
+      }
       /**
        * Build the options form.
        */
       function options_form(&$form, &$form_state) {
       public function options_form(&$form, &$form_state) {
         // Some form elements belong in a fieldset for presentation, but can't
         // be moved into one because of the form_state['values'] hierarchy. Those
         // elements can add a #fieldset => 'fieldset_name' property, and they'll
-...
        * Perform any necessary changes to the form values prior to storage.
        * There is no need for this function to actually store the data.
        */
       function options_submit(&$form, &$form_state) { }
       public function options_submit(&$form, &$form_state) {
+      }
       /**
        * Provides the handler some groupby.
        */
       function use_group_by() {
       public function use_group_by() {
         return TRUE;
+      }
       /**
        * Provide a form for aggregation settings.
        */
       function groupby_form(&$form, &$form_state) {
       public function groupby_form(&$form, &$form_state) {
         $view = &$form_state['view'];
         $display_id = $form_state['display_id'];
         $types = views_object_types();
-...
        * Perform any necessary changes to the form values prior to storage.
        * There is no need for this function to actually store the data.
        */
       function groupby_form_submit(&$form, &$form_state) {
       public function groupby_form_submit(&$form, &$form_state) {
         $item =& $form_state['handler']->options;
         $item['group_type'] = $form_state['values']['options']['group_type'];
-...
        * If a handler has 'extra options' it will get a little settings widget and
        * another form called extra_options.
        */
       function has_extra_options() { return FALSE; }
       public function has_extra_options() {
         return FALSE;
+      }
       /**
        * Provide defaults for the handler.
        */
       function extra_options(&$option) { }
       public function extra_options(&$option) {
+      }
       /**
        * Provide a form for setting options.
        */
       function extra_options_form(&$form, &$form_state) { }
       public function extra_options_form(&$form, &$form_state) {
+      }
       /**
        * Validate the options form.
        */
       function extra_options_validate($form, &$form_state) { }
       public function extra_options_validate($form, &$form_state) {
+      }
       /**
        * Perform any necessary changes to the form values prior to storage.
        * There is no need for this function to actually store the data.
        */
       function extra_options_submit($form, &$form_state) { }
       public function extra_options_submit($form, &$form_state) {
+      }
       /**
        * Determine if a handler can be exposed.
        */
       function can_expose() { return FALSE; }
       public function can_expose() {
         return FALSE;
+      }
       /**
        * Set new exposed option defaults when exposed setting is flipped
        * on.
        */
       function expose_options() { }
       public function expose_options() {
+      }
       /**
        * Get information about the exposed form for the form renderer.
        */
       function exposed_info() { }
       public function exposed_info() {
+      }
       /**
        * Render our chunk of the exposed handler form when selecting
        * Render our chunk of the exposed handler form when selecting.
        */
       function exposed_form(&$form, &$form_state) { }
       public function exposed_form(&$form, &$form_state) {
+      }
       /**
        * Validate the exposed handler form
        * Validate the exposed handler form.
        */
       function exposed_validate(&$form, &$form_state) { }
       public function exposed_validate(&$form, &$form_state) {
+      }
       /**
        * Submit the exposed handler form
        * Submit the exposed handler form.
        */
       function exposed_submit(&$form, &$form_state) { }
       public function exposed_submit(&$form, &$form_state) {
+      }
       /**
        * Form for exposed handler options.
        */
       function expose_form(&$form, &$form_state) { }
       public function expose_form(&$form, &$form_state) {
+      }
       /**
        * Validate the options form.
        */
       function expose_validate($form, &$form_state) { }
       public function expose_validate($form, &$form_state) {
+      }
       /**
        * Perform any necessary changes to the form exposes prior to storage.
        * There is no need for this function to actually store the data.
        */
       function expose_submit($form, &$form_state) { }
       public function expose_submit($form, &$form_state) {
+      }
       /**
        * Shortcut to display the expose/hide button.
        */
       function show_expose_button(&$form, &$form_state) { }
       public function show_expose_button(&$form, &$form_state) {
+      }
       /**
        * Shortcut to display the exposed options form.
        */
       function show_expose_form(&$form, &$form_state) {
       public function show_expose_form(&$form, &$form_state) {
         if (empty($this->options['exposed'])) {
           return;
+        }
-...
       /**
        * Check whether current user has access to this handler.
+       *
        * @return boolean
        * @return bool
        */
       function access() {
       public function access() {
         if (isset($this->definition['access callback']) && function_exists($this->definition['access callback'])) {
           if (isset($this->definition['access arguments']) && is_array($this->definition['access arguments'])) {
             return call_user_func_array($this->definition['access callback'], $this->definition['access arguments']);
-...
        * This gives all the handlers some time to set up before any handler has
        * been fully run.
        */
       function pre_query() { }
       public function pre_query() {
+      }
       /**
        * Run after the view is executed, before the result is cached.
-...
        * used so that handlers that pull up secondary data can put it in the
        * $values so that the raw data can be utilized externally.
        */
       function post_execute(&$values) { }
       public function post_execute(&$values) {
+      }
       /**
        * Provides a unique placeholders for handlers.
        */
       function placeholder() {
       public function placeholder() {
         return $this->query->placeholder($this->options['table'] . '_' . $this->options['field']);
+      }
-...
        * Called just prior to query(), this lets a handler set up any relationship
        * it needs.
        */
       function set_relationship() {
       public function set_relationship() {
         // Ensure this gets set to something.
         $this->relationship = NULL;
-...
        * Ensure the main table for this handler is in the query. This is used
        * a lot.
        */
       function ensure_my_table() {
       public function ensure_my_table() {
         if (!isset($this->table_alias)) {
           if (!method_exists($this->query, 'ensure_table')) {
             vpr(t('Ensure my table called but query has no ensure_table method.'));
-...
+      }
       /**
        * Provide text for the administrative summary
        * Provide text for the administrative summary.
        */
       function admin_summary() { }
       public function admin_summary() {
+      }
       /**
        * Determine if the argument needs a style plugin.
+       *
        * @return TRUE/FALSE
        * @return bool
        */
       function needs_style_plugin() { return FALSE; }
       public function needs_style_plugin() {
         return FALSE;
+      }
       /**
        * Determine if this item is 'exposed', meaning it provides form elements
        * to let users modify the view.
+       *
        * @return TRUE/FALSE
        * @return bool
        */
       function is_exposed() {
       public function is_exposed() {
         return !empty($this->options['exposed']);
+      }
       /**
        * Returns TRUE if the exposed filter works like a grouped filter.
        */
       function is_a_group() { return FALSE; }
       public function is_a_group() {
         return FALSE;
+      }
       /**
        * Define if the exposed input has to be submitted multiple times.
        * This is TRUE when exposed filters grouped are using checkboxes as
        * widgets.
        */
       function multiple_exposed_input() { return FALSE; }
       public function multiple_exposed_input() {
         return FALSE;
+      }
       /**
        * Take input from exposed handlers and assign to this handler, if necessary.
        */
       function accept_exposed_input($input) { return TRUE; }
       public function accept_exposed_input($input) {
         return TRUE;
+      }
       /**
        * If set to remember exposed input in the session, store it there.
        */
       function store_exposed_input($input, $status) { return TRUE; }
       public function store_exposed_input($input, $status) {
         return TRUE;
+      }
       /**
        * Get the join object that should be used for this handler.
-...
        * getting the join if it is necessary to make some changes to it, such
        * as adding an 'extra'.
        */
       function get_join() {
       public function get_join() {
         // get the join from this table that links back to the base table.
         // Determine the primary table to seek
         // Determine the primary table to seek.
         if (empty($this->query->relationships[$this->relationship])) {
           $base_table = $this->query->base_table;
+        }
-...
+       *
        * @see views_handler::options_validate()
+       *
        * @return
        *   Empty array if the handler is valid; an array of error strings if it is not.
        * @return array
        *   Empty array if the handler is valid; an array of error strings if it is
        *   not.
        */
       function validate() { return array(); }
       public function validate() {
         return array();
+      }
       /**
        * Determine if the handler is considered 'broken', meaning it's a
        * a placeholder used when a handler can't be found.
        * Determine if the handler is considered 'broken'.
+       *
        * Generally only returns TRUE if the handler can't be found.
+       *
        * @return bool
        *   The handler could not be loaded.
        */
       function broken() { }
       public function broken() {
+      }
+    }
     /**
-...
      * definition terms:
      * - numeric: If true, treat this field as numeric, using %d instead of %s in
      *            queries.
+     *
      */
     class views_many_to_one_helper {
       /**
        * Contains possible existing placeholders used by the query.
+       *
-...
        */
       public $placeholders = array();
       function __construct(&$handler) {
       /**
        * {@inheritdoc}
        */
       public function __construct(&$handler) {
         $this->handler = &$handler;
+      }
       /**
        * {@inheritdoc}
        */
       static function option_definition(&$options) {
         $options['reduce_duplicates'] = array('default' => FALSE, 'bool' => TRUE);
+      }
       function options_form(&$form, &$form_state) {
       /**
        * {@inheritdoc}
        */
       public function options_form(&$form, &$form_state) {
         $form['reduce_duplicates'] = array(
           '#type' => 'checkbox',
           '#title' => t('Reduce duplicates'),
-...
+      }
       /**
        * Sometimes the handler might want us to use some kind of formula, so give
        * it that option. If it wants us to do this, it must set $helper->formula = TRUE
        * and implement handler->get_formula();
        * Provide an option to use a formula.
+       *
        * If it wants us to do this, it must set $helper->formula = TRUE and
        * implement handler->get_formula();.
        */
       function get_field() {
       public function get_field() {
         if (!empty($this->formula)) {
           return $this->handler->get_formula();
+        }
-...
       /**
        * Add a table to the query.
+       *
        * This is an advanced concept; not only does it add a new instance of the table,
        * but it follows the relationship path all the way down to the relationship
        * link point and adds *that* as a new relationship and then adds the table to
        * the relationship, if necessary.
        * This is an advanced concept; not only does it add a new instance of the
        * table, but it follows the relationship path all the way down to the
        * relationship link point and adds *that* as a new relationship and then adds
        * the table to the relationship, if necessary.
        */
       function add_table($join = NULL, $alias = NULL) {
       public function add_table($join = NULL, $alias = NULL) {
         // This is used for lookups in the many_to_one table.
         $field = $this->handler->relationship . '_' . $this->handler->table . '.' . $this->handler->field;
-...
           $join = $this->get_join();
+        }
         // See if there's a chain between us and the base relationship. If so, we need
         // to create a new relationship to use.
         // See if there's a chain between us and the base relationship. If so, we
         // need to create a new relationship to use.
         $relationship = $this->handler->relationship;
         // Determine the primary table to seek
         // Determine the primary table to seek.
         if (empty($this->handler->query->relationships[$relationship])) {
           $base_table = $this->handler->query->base_table;
+        }
-...
         // Cycle through the joins. This isn't as error-safe as the normal
         // ensure_path logic. Perhaps it should be.
         $r_join = clone $join;
         while ($r_join->left_table != $base_table) {
         while (!empty($r_join) && $r_join->left_table != $base_table) {
           $r_join = views_get_table_join($r_join->left_table, $base_table);
+        }
         // If we found that there are tables in between, add the relationship.
-...
         return $alias;
+      }
       function get_join() {
       /**
        * {@inheritdoc}
        */
       public function get_join() {
         return $this->handler->get_join();
+      }
       /**
        * Provide the proper join for summary queries. This is important in part because
        * it will cooperate with other arguments if possible.
        * Provide the proper join for summary queries.
+       *
        * This is important in part because it will cooperate with other arguments if
        * possible.
        */
       function summary_join() {
       public function summary_join() {
         $field = $this->handler->relationship . '_' . $this->handler->table . '.' . $this->handler->field;
         $join = $this->get_join();
         // shortcuts
         // Shortcuts.
         $options = $this->handler->options;
         $view = &$this->handler->view;
         $query = &$this->handler->query;
-...
       /**
        * Override ensure_my_table so we can control how this joins in.
+       *
        * The operator actually has influence over joining.
        */
       function ensure_my_table() {
       public function ensure_my_table() {
         if (!isset($this->handler->table_alias)) {
           // Case 1: Operator is an 'or' and we're not reducing duplicates.
           // We hence get the absolute simplest:
           // We hence get the absolute simplest.
           $field = $this->handler->relationship . '_' . $this->handler->table . '.' . $this->handler->field;
           if ($this->handler->operator == 'or' && empty($this->handler->options['reduce_duplicates'])) {
             if (empty($this->handler->options['add_table']) && empty($this->handler->view->many_to_one_tables[$field])) {
               // query optimization, INNER joins are slightly faster, so use them
               // Query optimization, INNER joins are slightly faster, so use them
               // when we know we can.
               $join = $this->get_join();
               if (isset($join)) {
-...
           // Case 2: it's an 'and' or an 'or'.
           // We do one join per selected value.
           if ($this->handler->operator != 'not') {
             // Clone the join for each table:
             // Clone the join for each table.
             $this->handler->table_aliases = array();
             foreach ($this->handler->value as $value) {
               $join = $this->get_join();
-...
+            }
+          }
           // Case 3: it's a 'not'.
           // We just do one join. We'll add a where clause during
           // the query phase to ensure that $table.$field IS NULL.
           // We just do one join. We'll add a where clause during the query phase
           // to ensure that $table.$field IS NULL.
           else {
             $join = $this->get_join();
             $join->type = 'LEFT';
-...
       /**
        * Provides a unique placeholders for handlers.
        */
       function placeholder() {
       public function placeholder() {
         return $this->handler->query->placeholder($this->handler->options['table'] . '_' . $this->handler->options['field']);
+      }
       function add_filter() {
       /**
+       *
        */
       public function add_filter() {
         if (empty($this->handler->value)) {
           return;
+        }
         $this->handler->ensure_my_table();
         // Shorten some variables:
         // Shorten some variables.
         $field = $this->get_field();
         $options = $this->handler->options;
         $operator = $this->handler->operator;
-...
           $options['group'] = 0;
+        }
         // add_condition determines whether a single expression is enough(FALSE) or the
         // conditions should be added via an db_or()/db_and() (TRUE).
         // Determine whether a single expression is enough(FALSE) or the conditions
         // should be added via an db_or()/db_and() (TRUE).
         $add_condition = TRUE;
         if ($operator == 'not') {
           $value = NULL;
-...
             $clause->condition("$alias.$field", $value);
+          }
           // implode on either AND or OR.
           // Implode on either AND or OR.
           $this->handler->query->add_where($options['group'], $clause);
+        }
+      }
+    }
     /**
      * Break x,y,z and x+y+z into an array. Works for strings.
+     *
      * @param $str
      * @param string $str
      *   The string to parse.
      * @param $object
      *   The object to use as a base. If not specified one will
      *   be created.
      * @param object $object
      *   The object to use as a base. If not specified one will be created.
+     *
      * @return $object
      * @return object
      *   An object containing
      *   - operator: Either 'and' or 'or'
      *   - value: An array of numeric values.
-...
         $handler = new stdClass();
+      }
       // Set up defaults:
       // Set up defaults.
       if (!isset($handler->value)) {
         $handler->value = array();
+      }
-...
     /**
      * Break x,y,z and x+y+z into an array. Numeric only.
+     *
      * @param $str
      * @param string $str
      *   The string to parse.
      * @param $handler
      *   The handler object to use as a base. If not specified one will
      *   be created.
      * @param object $handler
      *   The handler object to use as a base. If not specified one will be created.
+     *
      * @return $handler
      *   The new handler object.
-...
         $handler = new stdClass();
+      }
       // Set up defaults:
       // Set up defaults.
       if (!isset($handler->value)) {
         $handler->value = array();
+      }
-...
+    }
     // --------------------------------------------------------------------------
     // Date helper functions
     // Date helper functions.
     /**
      * Figure out what timezone we're in; needed for some date manipulations.
      */
-...
         $timezone = variable_get('date_default_timezone', 0);
+      }
       // set up the database timezone
       // Set up the database timezone.
       $db_type = Database::getConnection()->databaseType();
       if (in_array($db_type, array('mysql', 'pgsql'))) {
         $offset = '+00:00';
-...
             db_query("SET @@session.time_zone = '$offset'");
+          }
           $already_set = true;
           $already_set = TRUE;
+        }
+      }
-...
     /**
      * Helper function to create cross-database SQL dates.
+     *
      * @param $field
      * @param string $field
      *   The real table and field name, like 'tablename.fieldname'.
      * @param $field_type
      * @param string $field_type
      *  The type of date field, 'int' or 'datetime'.
      * @param $set_offset
      * @param string $set_offset
      *   The name of a field that holds the timezone offset or a fixed timezone
      *   offset value. If not provided, the normal Drupal timezone handling
      *   will be used, i.e. $set_offset = 0 will make no timezone adjustment.
      * @return
+     *
      * @return string
      *   An appropriate SQL string for the db type and field type.
      */
     function views_date_sql_field($field, $field_type = 'int', $set_offset = NULL) {
-...
             case 'int':
               $field = "DATE_ADD('19700101', INTERVAL $field SECOND)";
               break;
             case 'datetime':
               break;
+          }
-...
             $field = "($field + INTERVAL $offset_seconds SECOND)";
+          }
           return $field;
         case 'pgsql':
           switch ($field_type) {
             case 'int':
               $field = "TO_TIMESTAMP($field)";
               break;
             case 'datetime':
               break;
+          }
-...
             $field = "($field + INTERVAL '$offset_seconds SECONDS')";
+          }
           return $field;
         case 'sqlite':
           if (!empty($offset)) {
             $field = "($field + '$offset_seconds')";
-...
     /**
      * Helper function to create cross-database SQL date formatting.
+     *
      * @param $format
      * @param string $format
      *   A format string for the result, like 'Y-m-d H:i:s'.
      * @param $field
      * @param string $field
      *   The real table and field name, like 'tablename.fieldname'.
      * @param $field_type
      * @param string $field_type
      *   The type of date field, 'int' or 'datetime'.
      * @param $set_offset
      * @param string $set_offset
      *   The name of a field that holds the timezone offset or a fixed timezone
      *   offset value. If not provided, the normal Drupal timezone handling
      *   will be used, i.e. $set_offset = 0 will make no timezone adjustment.
      * @return
      *   offset value. If not provided, the normal Drupal timezone handling will be
      *   used, i.e. $set_offset = 0 will make no timezone adjustment.
+     *
      * @return string
      *   An appropriate SQL string for the db type and field type.
      */
     function views_date_sql_format($format, $field, $field_type = 'int', $set_offset = NULL) {
-...
             'i' => '%i',
             's' => '%s',
             'A' => '%p',
             );
           );
           $format = strtr($format, $replace);
           return "DATE_FORMAT($field, '$format')";
         case 'pgsql':
           $replace = array(
             'Y' => 'YYYY',
             'y' => 'YY',
             'M' => 'Mon',
             'm' => 'MM',
             'n' => 'MM', // no format for Numeric representation of a month, without leading zeros
             // No format for Numeric representation of a month, without leading
             // zeros.
             'n' => 'MM',
             'F' => 'Month',
             'D' => 'Dy',
             'd' => 'DD',
             'l' => 'Day',
             'j' => 'DD', // no format for Day of the month without leading zeros
             // No format for Day of the month without leading zeros.
             'j' => 'DD',
             'W' => 'WW',
             'H' => 'HH24',
             'h' => 'HH12',
             'i' => 'MI',
             's' => 'SS',
             'A' => 'AM',
             );
           );
           $format = strtr($format, $replace);
           return "TO_CHAR($field, '$format')";
         case 'sqlite':
           $replace = array(
             'Y' => '%Y', // 4 digit year number
             'y' => '%Y', // no format for 2 digit year number
             'M' => '%m', // no format for 3 letter month name
             'm' => '%m', // month number with leading zeros
             'n' => '%m', // no format for month number without leading zeros
             'F' => '%m', // no format for full month name
             'D' => '%d', // no format for 3 letter day name
             'd' => '%d', // day of month number with leading zeros
             'l' => '%d', // no format for full day name
             'j' => '%d', // no format for day of month number without leading zeros
             'W' => '%W', // ISO week number
             'H' => '%H', // 24 hour hour with leading zeros
             'h' => '%H', // no format for 12 hour hour with leading zeros
             'i' => '%M', // minutes with leading zeros
             's' => '%S', // seconds with leading zeros
             'A' => '', // no format for  AM/PM
             // 4 digit year number.
             'Y' => '%Y',
             // No format for 2 digit year number.
             'y' => '%Y',
             // No format for 3 letter month name.
             'M' => '%m',
             // Month number with leading zeros.
             'm' => '%m',
             // No format for month number without leading zeros.
             'n' => '%m',
             // No format for full month name.
             'F' => '%m',
             // No format for 3 letter day name.
             'D' => '%d',
             // Day of month number with leading zeros.
             'd' => '%d',
             // No format for full day name.
             'l' => '%d',
             // No format for day of month number without leading zeros.
             'j' => '%d',
             // ISO week number.
             'W' => '%W',
             // 24 hour hour with leading zeros.
             'H' => '%H',
             // No format for 12 hour hour with leading zeros.
             'h' => '%H',
             // Minutes with leading zeros.
             'i' => '%M',
             // Seconds with leading zeros.
             's' => '%S',
             // No format for AM/PM.
             'A' => '',
           );
           $format = strtr($format, $replace);
           return "strftime('$format', $field, 'unixepoch')";
-...
     /**
      * Helper function to create cross-database SQL date extraction.
+     *
      * @param $extract_type
      * @param string $extract_type
      *   The type of value to extract from the date, like 'MONTH'.
      * @param $field
      * @param string $field
      *   The real table and field name, like 'tablename.fieldname'.
      * @param $field_type
      * @param string $field_type
      *   The type of date field, 'int' or 'datetime'.
      * @param $set_offset
      * @param string $set_offset
      *   The name of a field that holds the timezone offset or a fixed timezone
      *   offset value. If not provided, the normal Drupal timezone handling
      *   will be used, i.e. $set_offset = 0 will make no timezone adjustment.
      * @return
+     *
      * @return string
      *   An appropriate SQL string for the db type and field type.
      */
     function views_date_sql_extract($extract_type, $field, $field_type = 'int', $set_offset = NULL) {
-...
       $field = views_date_sql_field($field, $field_type, $set_offset);
       // Note there is no space after FROM to avoid db_rewrite problems
       // see http://drupal.org/node/79904.
       // @see http://drupal.org/node/79904.
       switch ($extract_type) {
       case('DATE'):
         return $field;
       case('YEAR'):
         return "EXTRACT(YEAR FROM($field))";
       case('MONTH'):
         return "EXTRACT(MONTH FROM($field))";
       case('DAY'):
         return "EXTRACT(DAY FROM($field))";
       case('HOUR'):
         return "EXTRACT(HOUR FROM($field))";
       case('MINUTE'):
         return "EXTRACT(MINUTE FROM($field))";
       case('SECOND'):
         return "EXTRACT(SECOND FROM($field))";
       case('WEEK'):  // ISO week number for date
         switch ($db_type) {
           case('mysql'):
             // WEEK using arg 3 in mysql should return the same value as postgres EXTRACT
             return "WEEK($field, 3)";
           case('pgsql'):
             return "EXTRACT(WEEK FROM($field))";
+        }
       case('DOW'):
         switch ($db_type) {
           case('mysql'):
             // mysql returns 1 for Sunday through 7 for Saturday
             // php date functions and postgres use 0 for Sunday and 6 for Saturday
             return "INTEGER(DAYOFWEEK($field) - 1)";
           case('pgsql'):
             return "EXTRACT(DOW FROM($field))";
+        }
       case('DOY'):
         switch ($db_type) {
           case('mysql'):
             return "DAYOFYEAR($field)";
           case('pgsql'):
             return "EXTRACT(DOY FROM($field))";
+        }
         case('DATE'):
           return $field;
         case('YEAR'):
           return "EXTRACT(YEAR FROM($field))";
         case('MONTH'):
           return "EXTRACT(MONTH FROM($field))";
         case('DAY'):
           return "EXTRACT(DAY FROM($field))";
         case('HOUR'):
           return "EXTRACT(HOUR FROM($field))";
         case('MINUTE'):
           return "EXTRACT(MINUTE FROM($field))";
         case('SECOND'):
           return "EXTRACT(SECOND FROM($field))";
         case('WEEK'):
           // ISO week number for date.
           switch ($db_type) {
             case('mysql'):
               // WEEK using arg 3 in mysql should return the same value as postgres
               // EXTRACT.
               return "WEEK($field, 3)";
             case('pgsql'):
               return "EXTRACT(WEEK FROM($field))";
+          }
         case('DOW'):
           switch ($db_type) {
             // MySQL returns 1 for Sunday through 7 for Saturday.
             case('mysql'):
               return "INTEGER(DAYOFWEEK($field) - 1)";
             // PHP date functions and postgres use 0 for Sunday and 6 for Saturday.
             case('pgsql'):
               return "EXTRACT(DOW FROM($field))";
+          }
         case('DOY'):
           switch ($db_type) {
             case('mysql'):
               return "DAYOFYEAR($field)";
             case('pgsql'):
               return "EXTRACT(DOY FROM($field))";
+          }
+      }
+    }
-...
      *   // PHP 4 doesn't call constructors of the base class automatically from a
      *   // constructor of a derived class. It is your responsibility to propagate
      *   // the call to constructors upstream where appropriate.
      *   function construct($table = NULL, $left_table = NULL, $left_field = NULL, $field = NULL, $extra = array(), $type = 'LEFT') {
      *   public function construct($table = NULL, $left_table = NULL, $left_field = NULL, $field = NULL, $extra = array(), $type = 'LEFT') {
      *     parent::construct($table, $left_table, $left_field, $field, $extra, $type);
      *   }
+     *
      *   function build_join($select_query, $table, $view_query) {
      *   public function build_join($select_query, $table, $view_query) {
      *     $this->extra = 'foo.bar = baz.boing';
      *     parent::build_join($select_query, $table, $view_query);
      *   }
-...
+     *
      * Extensions of this class can be used to create more interesting joins.
+     *
      * join definition
      * 'join' definition:
      *   - table: table to join (right table)
      *   - field: field to join on (right field)
      *   - left_table: The table we join to
-...
      *       alias. If you use realtime joins, it works better.
      *   - - field: Field or formula
      *       in formulas we can reference the right table by using %alias
      *       @see SelectQueryInterface::addJoin()
      *   - - operator: defaults to =
      *   - - value: Must be set. If an array, operator will be defaulted to IN.
      *   - - numeric: If true, the value will not be surrounded in quotes.
      *   - - extra type: How all the extras will be combined. Either AND or OR. Defaults to AND.
+     *
      * @see SelectQueryInterface::addJoin()
      *   - operator: Defaults to =.
      *   - value: Must be set. If an array, operator will be defaulted to IN.
      *   - numeric: If true, the value will not be surrounded in quotes.
      *   - extra type: How all the extras will be combined. Either AND or OR.
      *     Defaults to AND.
      */
     class views_join {
       var $table = NULL;
       var $left_table = NULL;
       var $left_field = NULL;
       var $field = NULL;
       var $extra = NULL;
       var $type = NULL;
       var $definition = array();
       public $table = NULL;
       public $left_table = NULL;
       public $left_field = NULL;
       public $field = NULL;
       public $extra = NULL;
       public $type = NULL;
       public $definition = array();
       /**
        * Construct the views_join object.
        */
       function construct($table = NULL, $left_table = NULL, $left_field = NULL, $field = NULL, $extra = array(), $type = 'LEFT') {
       public function construct($table = NULL, $left_table = NULL, $left_field = NULL, $field = NULL, $extra = array(), $type = 'LEFT') {
         $this->extra_type = 'AND';
         if (!empty($table)) {
           $this->table = $table;
-...
           $this->type = strtoupper($type);
+        }
         elseif (!empty($this->definition)) {
           // if no arguments, construct from definition.
           // These four must exist or it will throw notices.
           // If no arguments, construct from definition. These four must exist or
           // it will throw notices.
           $this->table = $this->definition['table'];
           $this->left_table = $this->definition['left_table'];
           $this->left_field = $this->definition['left_field'];
-...
+       *
        * When possible, try to use table alias instead of table names.
+       *
        * @param $select_query
        *   An implementation of SelectQueryInterface.
        * @param $table
        * @param SelectQueryInterface $select_query
        *   An Implements SelectQueryInterface.
        * @param string $table
        *   The base table to join.
        * @param $view_query
        *   The source query, implementation of views_plugin_query.
        * @param views_plugin_query $view_query
        *   The source query, Implements views_plugin_query.
        */
       function build_join($select_query, $table, $view_query) {
       public function build_join($select_query, $table, $view_query) {
         if (empty($this->definition['table formula'])) {
           $right_table = $this->table;
+        }
-...
           $left_field = "$left[alias].$this->left_field";
+        }
         else {
           // This can be used if left_field is a formula or something. It should be used only *very* rarely.
           // This can be used if left_field is a formula or something. It should be
           // used only *very* rarely.
           $left_field = $this->left_field;
+        }
-...
           foreach ($this->extra as $info) {
             if (is_array($info)) {
               $extra = '';
               // Figure out the table name. Remember, only use aliases provided
               // if at all possible.
               // Figure out the table name. Remember, only use aliases provided if
               // at all possible.
               $join_table = '';
               if (!array_key_exists('table', $info)) {
                 $join_table = $table['alias'] . '.';
-...
+              }
               // Convert a single-valued array of values to the single-value case,
               // and transform from IN() notation to = notation
               // and transform from IN() notation to = notation.
               if (is_array($info['value']) && count($info['value']) == 1) {
                 if (empty($info['operator'])) {
                   $operator = '=';
-...
           if ($extras) {
             if (count($extras) == 1) {
               $condition .= ' AND ' . array_shift($extras);
               $condition .= ' AND (' . array_shift($extras) . ')';
+            }
             else {
               $condition .= ' AND (' . implode(' ' . $this->extra_type . ' ', $extras) . ')';
-...
     /**
      * Join handler for relationships that join with a subquery as the left field.
      * eg:
+     *
      * For example:
      *  LEFT JOIN node node_term_data ON ([YOUR SUBQUERY HERE]) = node_term_data.nid
+     *
      * join definition
      *   same as views_join class above, except:
      * 'join' definition:
      *   Same as views_join class above, except:
      *   - left_query: The subquery to use in the left side of the join clause.
      */
     class views_join_subquery extends views_join {
       function construct($table = NULL, $left_table = NULL, $left_field = NULL, $field = NULL, $extra = array(), $type = 'LEFT') {
       /**
        * {@inheritdoc}
        */
       public function construct($table = NULL, $left_table = NULL, $left_field = NULL, $field = NULL, $extra = array(), $type = 'LEFT') {
         parent::construct($table, $left_table, $left_field, $field, $extra, $type);
         $this->left_query = $this->definition['left_query'];
+      }
-...
       /**
        * Build the SQL for the join this object represents.
+       *
        * @param $select_query
        *   An implementation of SelectQueryInterface.
        * @param $table
        * @param object $select_query
        *   An Implements SelectQueryInterface.
        * @param string $table
        *   The base table to join.
        * @param $view_query
        *   The source query, implementation of views_plugin_query.
        * @return
+       *
        * @param array $view_query
        *   The source query, Implements views_plugin_query.
        */
       function build_join($select_query, $table, $view_query) {
       public function build_join($select_query, $table, $view_query) {
         if (empty($this->definition['table formula'])) {
           $right_table = "{" . $this->table . "}";
+        }
-...
         // Tack on the extra.
         // This is just copied verbatim from the parent class, which itself has a
         // bug: http://drupal.org/node/1118100
         // bug.
         // @see http://drupal.org/node/1118100
         if (isset($this->extra)) {
           // If extra has been provided as string instead of an array, convert it
           // to an array.
-...
           foreach ($this->extra as $info) {
             if (is_array($info)) {
               $extra = '';
               // Figure out the table name. Remember, only use aliases provided
               // if at all possible.
               // Figure out the table name. Remember, only use aliases provided if
               // at all possible.
               $join_table = '';
               if (!array_key_exists('table', $info)) {
                 $join_table = $table['alias'] . '.';
-...
           if ($extras) {
             if (count($extras) == 1) {
               $condition .= ' AND ' . array_shift($extras);
               $condition .= ' AND (' . array_shift($extras) . ')';
+            }
             else {
               $condition .= ' AND (' . implode(' ' . $this->extra_type . ' ', $extras) . ')';

Formats disponibles : Unified diff

Projet

Général

Profil

Club Drupal

Révision 5d12d676

Ajouté par Assos Assos il y a environ 6 ans