function views_fetch_fields

Fetch a list of all fields available for a given base type.

Parameters

array|string $base: A list or a single base_table, for example node.

string $type: The handler type, for example field or filter.

bool $grouping: Should the result grouping by its 'group' label.

Return value

array A keyed array of in the form of 'base_table' => 'Description'.

File

includes/admin.inc, line 5282

Code

function views_fetch_fields($base, $type, $grouping = FALSE) {
    static $fields = array();
    if (empty($fields)) {
        $data = views_fetch_data();
        // This constructs this ginormous multi dimensional array to
        // collect the important data about fields. In the end,
        // the structure looks a bit like this (using nid as an example)
        // $strings['nid']['filter']['title'] = 'string'.
        //
        // This is constructed this way because the above referenced strings
        // can appear in different places in the actual data structure so that
        // the data doesn't have to be repeated a lot. This essentially lets
        // each field have a cheap kind of inheritance.
        $components = array(
            'title',
            'group',
            'help',
            'base',
            'aliases',
        );
        $components_errors = array();
        // Fixed number of calls to t() to produce error components.
        foreach ($components as $string) {
            $components_errors[$string] = t("Error: missing @component", array(
                '@component' => $string,
            ));
        }
        foreach ($data as $table => $table_data) {
            $bases = array();
            $strings = array();
            $skip_bases = array();
            foreach ($table_data as $field => $info) {
                // Collect table data from this table.
                if ($field == 'table') {
                    // Calculate what tables this table can join to.
                    if (!empty($info['join'])) {
                        $bases = array_keys($info['join']);
                    }
                    // And it obviously joins to itself.
                    $bases[] = $table;
                    continue;
                }
                foreach (array(
                    'field',
                    'sort',
                    'filter',
                    'argument',
                    'relationship',
                    'area',
                ) as $key) {
                    if (!empty($info[$key])) {
                        if ($grouping && !empty($info[$key]['no group by'])) {
                            continue;
                        }
                        if (!empty($info[$key]['skip base'])) {
                            foreach ((array) $info[$key]['skip base'] as $base_name) {
                                $skip_bases[$field][$key][$base_name] = TRUE;
                            }
                        }
                        elseif (!empty($info['skip base'])) {
                            foreach ((array) $info['skip base'] as $base_name) {
                                $skip_bases[$field][$key][$base_name] = TRUE;
                            }
                        }
                        // Don't show old fields. The real field will be added right.
                        if (isset($info[$key]['moved to'])) {
                            continue;
                        }
                        foreach ($components as $string) {
                            // First, try the lowest possible level.
                            if (!empty($info[$key][$string])) {
                                $strings[$field][$key][$string] = $info[$key][$string];
                            }
                            elseif (!empty($info[$string])) {
                                $strings[$field][$key][$string] = $info[$string];
                            }
                            elseif (!empty($table_data['table'][$string])) {
                                $strings[$field][$key][$string] = $table_data['table'][$string];
                            }
                            else {
                                if ($string != 'base') {
                                    $strings[$field][$key][$string] = $components_errors[$string];
                                }
                            }
                        }
                    }
                }
            }
            foreach ($bases as $base_name) {
                foreach ($strings as $field => $field_strings) {
                    foreach ($field_strings as $type_name => $type_strings) {
                        if (empty($skip_bases[$field][$type_name][$base_name])) {
                            $fields[$base_name][$type_name]["{$table}.{$field}"] = $type_strings;
                        }
                    }
                }
            }
        }
    }
    // If we have an array of base tables available, go through them all and add
    // them together. Duplicate keys will be lost and that's Just Fine.
    if (is_array($base)) {
        $strings = array();
        foreach ($base as $base_table) {
            if (isset($fields[$base_table][$type])) {
                $strings += $fields[$base_table][$type];
            }
        }
        uasort($strings, '_views_sort_types');
        return $strings;
    }
    if (isset($fields[$base][$type])) {
        uasort($fields[$base][$type], '_views_sort_types');
        return $fields[$base][$type];
    }
    return array();
}