function content_copy_import_form_submit in Content Construction Kit (CCK) 6.2

Same name and namespace in other branches

1. 5 content_copy.module \content_copy_import_form_submit()
2. 6.3 modules/content_copy/content_copy.module \content_copy_import_form_submit()
3. 6 modules/content_copy/content_copy.module \content_copy_import_form_submit()

Submit handler for import form. For each submitted field: 1) add new field to the database 2) execute the imported field macro to update the settings to the imported values

File

modules/content_copy/content_copy.module, line 335

Adds capability to import/export CCK field data definitions.

Code

function content_copy_import_form_submit($form, &$form_state) {
  $form_values = $form_state['values'];

  // Get the content type we are importing into.
  $type_name = $form_values['type_name'];
  $type_label = node_get_types('name', $type_name);
  $content = NULL;

  // Convert the import formatted text back into a $content array.
  // Return if errors generated or not an array.
  // Use '@' to suppress errors about undefined constants in the macro.
  @eval($form_values['macro']);

  // Preliminary error trapping, must have valid arrays to work with.
  if (!isset($content) || !isset($content['type']) || !is_array($content) || !is_array($content['type'])) {
    form_set_error('macro', t('The import data is not valid import text.'));
    return;
  }
  module_load_include('inc', 'content', 'includes/content.crud');

  // Get all type and field info for this database.
  $content_info = _content_type_info();
  $imported_type = $content['type'];
  $imported_type_name = $imported_type['type'];
  $imported_type_label = $imported_type['name'];

  // It is allowed to import a type with no fields,
  // so the fields array could be empty and must be cast as an array.
  $imported_fields = isset($content['fields']) ? $content['fields'] : array();

  // Perform more pre-import error trapping.
  // If there are potential problems, exit without doing the import.
  $not_enabled = array();

  // The groups array could be empty and still valid, make sure to cast it as an array.
  // If there are groups in the import, make sure the fieldgroup module is enabled.
  $imported_groups = array();
  if (isset($content['groups']) && module_exists('fieldgroup')) {
    $imported_groups = (array) $content['groups'];
  }
  elseif (isset($content['groups']) && is_array($content['groups'])) {
    $not_enabled[] = 'fieldgroup';
  }

  // Make sure that all the field and widget modules in the import are enabled in this database.
  foreach ($imported_fields as $import) {
    $field = content_field_instance_collapse($import);
    if (empty($field['module']) || empty($field['widget_module'])) {
      $not_enabled[] = $field['field_name'];
    }
    else {
      if (!module_exists($field['module'])) {
        $not_enabled[] = $field['module'];
      }
      if (!module_exists($field['widget_module'])) {
        $not_enabled[] = $field['widget_module'];
      }
    }
  }

  // If any required module is not enabled, set an error message and exit.
  if ($not_enabled) {
    form_set_error('macro', t('The following modules must be enabled for this import to work: %modules.', array(
      '%modules' => implode(', ', array_unique($not_enabled)),
    )));
  }

  // Make sure the imported content type doesn't already exist in the database.
  if ($form_values['type_name'] == '<create>') {
    if (in_array($imported_type_name, array_keys($content_info['content types']))) {
      form_set_error('macro', t('The content type %type already exists in this database.', array(
        '%type' => $imported_type_name,
      )));
    }
  }
  if (form_get_errors()) {
    drupal_set_message(t('Exiting. No import performed.'), 'error');
    return;
  }

  // Create the content type, if requested.
  if ($form_values['type_name'] == '<create>') {
    $type = (object) $imported_type;
    $values = $imported_type;

    // Prevent a warning in node/content_types.inc
    $type->has_title = TRUE;
    $type_form_state = array(
      'values' => $values,
    );

    // There's no API for creating node types, we still have to use drupal_execute().
    drupal_execute('node_type_form', $type_form_state, $type);

    // Reset type and database values once new type has been added.
    $type_name = $imported_type_name;
    $type_label = node_get_types('name', $type_name);
    content_clear_type_cache();
    $content_info = _content_type_info();
    if (form_get_errors() || !isset($content_info['content types']) || !is_array($content_info['content types'][$type_name])) {
      drupal_set_message(t('An error has occurred adding the content type %type.<br/>Please check the errors displayed for more details.', array(
        '%type' => $imported_type_name,
      )));
      return;
    }
  }

  // Create the groups for this type, if they don't already exist.
  if (module_exists('fieldgroup') && $imported_groups) {
    foreach ($imported_groups as $group) {
      $group_name = $group['group_name'];
      fieldgroup_save_group($type_name, $group);
    }

    // Reset the static variable in fieldgroup_groups() with new data.
    fieldgroup_groups('', FALSE, TRUE);
  }

  // Iterate through the field forms in the import and execute each.
  $rebuild = FALSE;
  foreach ($imported_fields as $field) {

    // Make sure the field doesn't already exist in the type.
    // If so, do nothing, fields can't be duplicated within a content type.
    $field_name = $field['field_name'];

    // Might need to overwrite the content type name if a new type was created.
    $field['type_name'] = $type_name;
    if (!empty($field['field_name']) && isset($content_info['content types'][$type_name]['fields'][$field_name])) {
      drupal_set_message(t('The imported field %field_label (%field_name) was not added to %type because that field already exists in %type.', array(
        '%field_label' => $field['label'],
        '%field_name' => $field_name,
        '%type' => $type_label,
      )));
    }
    else {
      $field = content_field_instance_create($field, FALSE);
      $rebuild = TRUE;
      drupal_set_message(t('The field %field_label (%field_name) was added to the content type %type.', array(
        '%field_label' => $field['widget']['label'],
        '%field_name' => $field_name,
        '%type' => $type_label,
      )));
    }

    // Fieldgroup module erases all group related data when a module that
    // provides a content type is disabled, but CCK does not remove the fields.
    // In this case, we should ensure group data related to fields is properly
    // restored. Hence, we need to update field group data for newly imported
    // field, but also for fields that already exist.
    if (module_exists('fieldgroup') && isset($imported_groups)) {
      fieldgroup_update_fields($field);
    }
  }

  // Clear caches and rebuild menu only if any field has been created.
  if ($rebuild) {
    content_clear_type_cache(TRUE);
    menu_rebuild();
  }

  // Import weights of non-CCK fields.
  if (isset($content['extra'])) {
    variable_set('content_extra_weights_' . $type_name, $content['extra']);
  }
}