diff --git a/node_reference/node_reference.module b/node_reference/node_reference.module index 141de42..f842040 100644 --- a/node_reference/node_reference.module +++ b/node_reference/node_reference.module @@ -69,21 +69,134 @@ function node_reference_field_schema($field) { function node_reference_field_settings_form($field, $instance, $has_data) { $settings = $field['settings']; - $form = array(); - $form['referenceable_types'] = array( - '#type' => 'checkboxes', - '#title' => t('Content types that can be referenced'), - '#multiple' => TRUE, - '#default_value' => is_array($settings['referenceable_types']) - ? $settings['referenceable_types'] - : array(), - '#options' => array_map('check_plain', node_type_get_names()), - '#disabled' => $has_data, + $form = array( + 'referenceable_types' => array( + '#type' => 'item', + '#tree' => TRUE, + '#title' => t('Content types that can be referenced'), + ), ); + + // Get the currently referenced types. This will be an array (string => + // TRUE) when the SQL storage module is used. When another storage + // module is used, the return value will be NULL. + $referenced_types = _node_reference_retrieve_referenced_types($field); + + $node_type_names = node_type_get_names(); + natcasesort($node_type_names); + foreach ($node_type_names as $type => $label) { + $is_selected = is_string($settings['referenceable_types'][$type]) && $settings['referenceable_types'][$type] == $type; + + if ($has_data) { + if (isset($referenced_types)) { + // Data is present and it is known which types actually have + // references to them. Disable deselection of only these currently + // referenced types. + $is_disabled = (isset($referenced_types[$type]) && $referenced_types[$type]) ? TRUE: FALSE; + } + else { + // Data is present but it is not known which types actually have + // references to them. Disable deslection of all types that are + // currently selected as referenceable. + $is_disabled = $is_selected; + } + } + else { + // No data for this reference field at all. Allow deselection of all + // types. + $is_disabled = FALSE; + } + + $form['referenceable_types'][$type] = array( + '#type' => 'checkbox', + '#title' => check_plain($label), + '#default_value' => $is_selected, + '#return_value' => $type, + '#disabled' => $is_disabled, + '#element_validate' => array('node_reference_field_settings_referenceable_type_validate'), + ); + } + return $form; } /** + * Validate the type selection checkboxes. This function ensures that types + * that the user cannot deselect won't be deselected. + */ +function node_reference_field_settings_referenceable_type_validate($element, &$form_state) { + // If the checkbox is disabled (and therefore checked), either: + // - the SQL storage module is used and the type is actually referenced in + // the database, or + // - another storage module is used and the type was previously marked as + // referenceable by the user. + // + // In both cases do not allow the user to deselect the type. + if ($element['#disabled']) { + form_set_value($element, $element['#return_value'], $form_state); + } +} + +/** + * Retrieve the list of types that are actually referenced by the data of this + * field. If the SQL storage module is used it is possible to be more specific + * about the data of this field: instead of just indicating that data is + * present, the actual types referenced by this field can be retrieved. This + * information can be used to allow deselection of referenceable types for + * which no references are present in the database. + * <p> + * Only types that are referenced by the current revision of nodes are + * returned. This has two consequences: + * <ul> + * <li>It will be possible to deselect types which had references in the past + * but don't have references now. This allows you to disallow the selection of + * nodes of these types for references.</li> + * <li>If a revision referencing a type which is no longer selected is + * restored, you have to choose a node with one of the currently referenceable + * types when you edit the restored node. You won't be able to keep the old + * reference because its type is no longer allowed.</li> + * </ul> + * This function cannot handle other storage modules than the SQL storage + * module and will return NULL to indicate this. This allows the caller to + * distinguish between not being able to determine which types are actually + * referenced (NULL), and no types actually being referenced (empty array). + * + * @param Field $field + * The field for which to retrieve the actually referenced types. + * @return Array + * An array (string => TRUE) containing the IDs of types that are + * actually referenced in the database when the SQL storage module is + * used, or NULL when the SQL storage module is not used + */ +function _node_reference_retrieve_referenced_types($field) { + $referenced_types = NULL; + + $is_field_sql_storage = $field['storage']['type'] == 'field_sql_storage'; + if ($is_field_sql_storage) { + $referenced_types = array(); + + $current_data_details = $field['storage']['details']['sql']['FIELD_LOAD_CURRENT']; + $table_definition = array_keys($current_data_details); + $table_name = $table_definition[0]; + $nid_column_name = $current_data_details[$table_name]['nid']; + + $referenced_types_query = db_select($table_name, 'fd'); + $referenced_types_query->leftJoin('node', 'n', 'fd.' . $nid_column_name . ' = %alias.nid'); + $referenced_types_query->addField('n', 'type', 'rt'); + $referenced_types_query->distinct(); + $referenced_types_result = $referenced_types_query->execute(); + + $row = $referenced_types_result->fetchAssoc(); + while ($row) { + $referenced_types[$row['rt']] = TRUE; + $row = $referenced_types_result->fetchAssoc(); + } + } + + return $referenced_types; +} + +/** * Implements hook_field_validate(). * * Possible error codes: