bulk_photo_nodes.module

<?php
/**
 * @file
 * hooks and helper functions for bulk photo node.
 */

/**
 * Implements hook_permission().
 */
function bulk_photo_nodes_permission() {
  return array(
    'create bulk photo nodes' => array(
      'title' => t('Create bulk photo nodes'),
    ),
  );
}

/**
 * Implements hook_menu_alter().
 *
 * Replaces standard node add pages with bulk pages.
 */
function bulk_photo_nodes_menu_alter(&$items) {
  $bpn_var = variable_get('bulk_photo_node_types');
  if (!empty($bpn_var)) {
    foreach ($bpn_var as $node_type => $image_field) {
      $node_add_path = 'node/add/' . strtr($node_type, '_', '-');
      $items[$node_add_path]['page callback'] = 'bulk_photo_nodes_page';
      $items[$node_add_path]['page arguments'] = array($node_type);
      $items[$node_add_path]['access callback'] = 'user_access';
      $items[$node_add_path]['access arguments'] = array('create bulk photo nodes');
    }
  }
}

/**
 * Implements hook_form_node_type_form_alter().
 */
function bulk_photo_nodes_form_node_type_form_alter(&$form, &$form_state, $form_id) {
  $form['bulk_photo_nodes'] = array(
    '#tree' => TRUE,
    '#type' => 'fieldset',
    '#group' => 'additional_settings',
    '#title' => 'Bulk Photo Node Settings',
  );
  $form['bulk_photo_nodes']['image_field'] = array(
    '#type' => 'select',
    '#title' => 'Choose a field for the image',
    '#default_value' => bulk_photo_nodes_get_image_field($form['#node_type']->type),
    '#options' => bulk_photo_nodes_get_image_fields($form['#node_type']->type),
  );
  $form['#submit'][] = 'bulk_photo_nodes_submit';
}

/**
 * Form submission handler for bulk_photo_nodes_form_node_type_form_alter().
 */
function bulk_photo_nodes_submit($form, &$form_state) {
  $image_field = $form_state['values']['bulk_photo_nodes']['image_field'];
  $node_type = $form['#node_type']->type;
  $bpn_var = variable_get('bulk_photo_node_types');
  if (!empty($image_field) && $image_field != $bpn_var[$node_type]) {
    // Never runs.
    if ($image_field == 'none') {
      if (is_array($bpn_var) && array_key_exists($node_type, $bpn_var)) {
        unset($bpn_var[$node_type]);
      }
    }
    else {
      $bpn_var[$node_type] = $image_field;
    }
    variable_set('bulk_photo_node_types', $bpn_var);
    menu_rebuild();
    drupal_set_message("Bulk photo node settings saved.");
  }
}

/**
 * Returns a list of image fields for a given content type.
 *
 * @param string $node_type
 *   The name of the content type
 *
 * @return array
 *   An associative array where key = machine name, value = field label
 */
function bulk_photo_nodes_get_image_fields($node_type) {
  $image_fields = array(
    'none' => '- None -',
  );
  $fields_info = field_info_instances('node', $node_type);
  foreach ($fields_info as $field_name => $field_value) {
    $field_info = field_info_field($field_name);
    $type = $field_info['type'];
    if ($type == 'image') {
      $image_fields[$field_name] = $field_value['label'];
    }
  }
  return $image_fields;
}

/**
 * Indicates if a given content type is being used as bulk photo nodes.
 *
 * @param string $node_type
 *   The machine name of a content_type.
 *
 * @return string
 *   The machine name of the image field or 'none' if the content type isn't
 *   used.
 */
function bulk_photo_nodes_get_image_field($node_type) {
  $bpn_var = variable_get('bulk_photo_node_types');
  if (is_array($bpn_var)) {
    return (array_key_exists($node_type, $bpn_var)) ? $bpn_var[$node_type] : 'none';
  }
  return 'none';
}

/**
 * Page callback: Displays the first step of the bulk photo node upload form.
 *
 * In case the user would like to see the normal node/add form, simply supply
 * a query string of ?override=1
 *
 * @param string $node_type
 *   The content type of the node, used in case of an override.
 *
 * @return array
 *   A render array for the page.
 *
 * @see bulk_photo_nodes_menu_alter()
 */
function bulk_photo_nodes_page($node_type) {

  if (bulk_photo_nodes_is_bpn_add_page($node_type)) {

    drupal_add_css(drupal_get_path('module', 'bulk_photo_nodes') . '/css/bulk_photo_nodes_default.css');

    $content = array();
    $form_names = module_invoke_all('bulk_photo_nodes_method');
    $content_forms = array();
    $chosen_form = FALSE;

    foreach ($form_names as $form_name) {

      $form = drupal_get_form($form_name, $node_type);
      $content_forms[] = $form;

      if (array_key_exists('#bpn_chosen_form', $form)) {
        $chosen_form = $form;
        break;
      }
    }

    // If we've chosen a form, only include that one.
    if ($chosen_form) {
      $content['forms'] = array($chosen_form);
    }
    else {
      $content['forms'] = $content_forms;
    }

    return $content;

  }
  else {

    $form = node_add($node_type);
    return $form;

  }

}

/**
 * Determines if the current node add form is used by bulk photo nodes.
 *
 * @return bool
 *   TRUE if the current node add form  is used by bpn, FALSE otherwise.
 */
function bulk_photo_nodes_is_bpn_add_page($node_type) {
  $query = drupal_get_query_parameters();
  if (!is_array($query) || !array_key_exists('override', $query)) {
    $bpn_var = variable_get('bulk_photo_node_types');
    if (!empty($bpn_var)) {
      foreach ($bpn_var as $bpn_node_type => $image_field) {
        if ($bpn_node_type == $node_type) {
          return TRUE;
        }
      }
    }
  }
  return FALSE;
}

/**
 * Form constructor for final step of bpn_multistep_form().
 *
 * @ingroup forms
 */
function bulk_photo_nodes_add_form($form, &$form_state) {
  bulk_photo_nodes_chosen_form('bulk_photo_nodes_add_form');
  drupal_set_title(t('Add Description(s)'));

  $form = array();
  $form['#attached']['js'] = array(
    drupal_get_path('module', 'bulk_photo_nodes') . '/js/bulk_photo_nodes.js',
  );
  $form['#bpn_chosen_form'] = array(
    '#type' => 'value',
    '#value' => TRUE,
  );
  $form['#attributes'] = array(
    'class' => array('bpn-enabled'),
  );
  $form['nodes'] = array(
    '#tree' => TRUE,
    '#type' => 'fieldset',
    '#collapsed' => FALSE,
    '#prefix' => '<div id="bpn-nodes">' . '<p class="bpn-inline-help"><em>' . t('To apply the same descriptions to all photos, use Batch Settings on the right') . '<p></em>',
    '#suffix' => '</div>',
    '#attributes' => array(
      'class' => array(
        'bpn-left bpn-info clearfix',
      ),
    ),
  );

  // Since importing files is optionally a batch operation, look in $_SESSION
  // for a list of saved images.
  if (!empty($_SESSION['saved_files'])) {
    $form_state['saved_files'] = $_SESSION['saved_files'];
  }
  if (empty($form_state['saved_files'])) {
    drupal_goto("node/add/$form_state[node_type]");
  }

  foreach ($form_state['saved_files'] as $key => $file) {
    $extra_info = !empty($file['extra_info']) ? $file['extra_info'] : array();
    $vars = array(
      'style_name' => 'bulk_photo_nodes',
      'path' => $file['file_object']->uri,
      'attributes' => array('class' => 'bpn-info-node-image'),
    );
    $node = new stdClass();
    $node->type = $form_state['node_type'];
    node_object_prepare($node);
    $markup = theme('image_style', $vars);
    $form['nodes'][$key] = array(
      '#type' => 'fieldset',
      '#tree' => TRUE,
      '#collapsed' => FALSE,
      '#attributes' => array(
        'class' => array(
          'bpn-info-node',
        ),
      ),
    );
    $form['nodes'][$key]['left'] = array(
      '#type' => 'container',
      '#collapsed' => FALSE,
      '#attributes' => array(
        'class' => array(
          'bpn-info-node-left clearfix',
        ),
      ),
    );
    $form['nodes'][$key]['left']['image'] = array(
      '#type' => 'markup',
      '#markup' => $markup,
    );
    $form['nodes'][$key]['left']["delete_{$key}"] = array(
      '#type' => 'submit',
      '#value' => 'Delete',
      '#name' => $key,
      '#limit_validation_errors' => array(),
      '#submit' => array('bulk_photo_nodes_delete_node'),
      '#attributes' => array(
        'class' => array(
          'bpn-info-node-delete',
        ),
      ),
    );
    $form['nodes'][$key]['right'] = array(
      '#type' => 'fieldset',
      '#parents' => array(
        'nodes', $key, 'right',
      ),
      '#attributes' => array(
        'class' => array(
          'bpn-info-node-right clearfix',
        ),
      ),
    );
    $form['nodes'][$key]['right']['node'] = array(
      '#type' => 'fieldset',
      '#title' => t('Edit Additional Information'),
      '#collapsible' => TRUE,
      '#collapsed' => TRUE,
      '#parents' => array(
        'nodes', $key, 'right', 'node',
      ),
      '#attributes' => array(
        'class' => array(
          'bpn-info-node-additional',
        ),
      ),
      '#weight' => 10,
    );
    // Manually add a title form item since it's not a field.
    $default_title = array_key_exists('title', $extra_info) ? $extra_info['title'] : '';
    $form['nodes'][$key]['right']['title'] = array(
      '#type' => 'textfield',
      '#title' => 'Title',
      '#default_value' => $default_title,
      '#required' => (!empty($form_state['values']['override_fields']['fields']['title'])) ? FALSE : TRUE,
      '#weight' => -10,
      '#attributes' => array(
        'class' => array(
          'bpn-info-node-title',
        ),
      ),
    );

    // Attach all fields found in the node form.
    field_attach_form('node', $node, $form['nodes'][$key]['right']['node'], $form_state);

    // Manually attach file from plupload.
    $image_field = bulk_photo_nodes_get_image_field($node->type);
    unset($form['nodes'][$key]['right']['node'][$image_field]);
    $form['nodes'][$key]['right']['node'][$image_field]['und'][0]['#type'] = 'value';
    $form['nodes'][$key]['right']['node'][$image_field]['und'][0]['#value'] = (array) $file['file_object'];

    // Move body field around to proper fieldset.
    $form['nodes'][$key]['right']['body'] = $form['nodes'][$key]['right']['node']['body'];
    $form['nodes'][$key]['right']['node']['body']['#weight'] = 0;
    unset($form['nodes'][$key]['right']['node']['body']);
  }

  $form['override_fields'] = array(
    '#type' => 'container',
    '#tree' => TRUE,
    '#attributes' => array(
      'class' => array(
        'bpn-right clearfix',
      ),
    ),
  );
  $form['override_fields']['fields'] = array(
    '#parents' => array(
      'override_fields', 'fields',
    ),
  );
  $form['override_fields']['fields']['title_display'] = array(
    '#markup' => '<h2>Batch Settings</h2><p>(applies to all photos, unless overridden)</p>',
    '#weight' => -11,
  );
  field_attach_form('node', $node, $form['override_fields']['fields'], $form_state);
  $form['override_fields']['fields']['title'] = array(
    '#type' => 'textfield',
    '#title' => 'Title',
    '#required' => FALSE,
    '#weight' => -10,
  );
  unset($form['override_fields']['fields'][$image_field]);
  $form['override_fields']['finish'] = array(
    '#type' => 'submit',
    '#value' => t('Complete Upload'),
    '#submit' => array('bulk_photo_nodes_add_form_submit'),
  );

  bulk_photo_nodes_recursive_set_optional($form['override_fields']['fields']);
  bulk_photo_nodes_recursive_ajax($form['override_fields']['fields']);

  if (!empty($form_state['values']['override_fields']['fields'])) {
    // Required/optional logic.
    $override_node = (object) $form_state['values']['override_fields']['fields'];
    $override_node->type = $form_state['node_type'];
    foreach ($form_state['input']['override_fields']['fields'] as $field_name => $field) {
      // Check if field is empty.
      $field_has_value = bulk_photo_nodes_check_field_empty($field_name, $override_node);
      if ($field_has_value) {
        foreach (element_children($form['nodes']) as $key) {
          if (bulk_photo_nodes_is_required($form['nodes'][$key]['right']['node'][$field_name])) {
            bulk_photo_nodes_recursive_set_optional($form['nodes'][$key]['right']['node'][$field_name]);
          }
          if ($field_name == 'body') {
            if (bulk_photo_nodes_is_required($form['nodes'][$key]['right'][$field_name])) {
              bulk_photo_nodes_recursive_set_optional($form['nodes'][$key]['right'][$field_name]);
            }
          }
        }
      }
      else {
        // Field is empty.
        foreach (element_children($form['nodes']) as $key) {
          if (bulk_photo_nodes_is_required($form['nodes'][$key]['right']['node'][$field_name])) {
            bulk_photo_nodes_recursive_set_required($form['nodes'][$key]['right']['node'][$field_name]);
          }
          if ($field_name == 'body') {
            if (bulk_photo_nodes_is_required($form['nodes'][$key]['right'][$field_name])) {
              bulk_photo_nodes_recursive_set_required($form['nodes'][$key]['right'][$field_name]);
            }
          }
        }
      }
    }
  }
  drupal_alter('bulk_photo_nodes_overrides', $form, $form_state);
  return $form;
}

/**
 * AJAX callback for bulk_photo_nodes_add_form().
 */
function bulk_photo_nodes_add_form_ajax(&$form, &$form_state) {
  return $form['nodes'];
}


/**
 * Form submission handler for bulk_photo_nodes_add_form().
 */
function bulk_photo_nodes_add_form_submit($form, &$form_state) {
  // Convenience short aliases.
  $node_type = $form_state['node_type'];
  $nodes =& $form_state['values']['nodes'];
  $node_overrides =& $form_state['values']['override_fields']['fields'];
  $node_count = 0;
  $operations = array();
  foreach ($nodes as $key => $outer_node) {
    $operations[] = array(
      'bulk_photo_nodes_save_node',
      array($node_type, $outer_node, $node_overrides),
    );
  }
  $batch = array(
    'title' => t('Saving nodes'),
    'finished' => 'bulk_photo_nodes_batch_finished',
    'operations' => $operations,
  );
  batch_set($batch);
}

/**
 * Batch 'finished' callback used by bulk_photo_nodes_add_form_submit().
 */
function bulk_photo_nodes_batch_finished($success, $results, $operations) {
  if ($success) {
    drupal_set_message(t('@count Photos saved.', array('@count' => count($results))));

    // Delete old image style generated images.
    $image_style = image_style_load('bulk_photo_nodes');
    image_style_flush($image_style);
  }
  else {
    // An error occurred.
    // $operations contains the operations that remained unprocessed.
    $error_operation = reset($operations);
    drupal_set_message(t('An error occurred while processing @operation with arguments : @args', array(
      '@operation' => $error_operation[0], '@args' => print_r($error_operation[0], TRUE),
    )));
  }
}

/**
 * Deletes an individual bulk photo node.
 */
function bulk_photo_nodes_delete_node($form, &$form_state) {
  $key = $form_state['triggering_element']['#name'];
  file_delete($form_state['saved_files'][$key]['file_object']);
  unset($form_state['saved_files'][$key]);
  unset($form_state['values']['nodes'][$key]);
  $form_state['removal'] = $key;
  $form_state['rebuild'] = TRUE;
}

/**
 * Batch operation: Saves an individual bulk photo node.
 *
 * @param string $node_type
 *   The content type of the node.
 *
 * @param array $node_fields
 *   The fields of the given node.
 *
 * @param array $node_overrides
 *   Fields that will override $node_fields if they are empty.
 *
 * @return bool
 *   TRUE if the node was saved successfully, FALSE otherwise.
 */
function bulk_photo_nodes_save_node($node_type, $node_fields, $node_overrides, &$context) {
  // Move title and body back.
  $node_fields['right']['node']['body'] = $node_fields['right']['body'];
  $node_fields['right']['node']['title'] = $node_fields['right']['title'];
  // Update batch operation progressbar.
  $context['message'] = t('Saving node "@title"', array('@title' => $node_fields['right']['node']['title']));
  $context['results'][] = $node_fields['right']['node']['title'];

  unset($node_fields['right']['body']);
  unset($node_fields['right']['title']);
  // Prepare a new node for saving.
  $node = (object) $node_fields['right']['node'];
  $node->type = $node_type;
  $node->language = LANGUAGE_NONE;
  node_object_prepare($node);
  // Move the file from public to field-defined destination.
  $options = bulk_photo_nodes_get_file_info($node_type);
  $image_field_name = $options['field_name'];
  $image_field_ref =& $node->{$image_field_name}[LANGUAGE_NONE][0];
  $image_field = (object) $node->{$image_field_name}[LANGUAGE_NONE][0];
  $extension = pathinfo($image_field->filename, PATHINFO_EXTENSION);
  $query_string = "SELECT COUNT(nid) FROM {node} WHERE type = :node_type AND uid = :uid";
  $images_count = db_query($query_string, array(
    ':node_type' => $node_type, ':uid' => $image_field->uid,
  ))->fetchField();
  $images_count++;
  drupal_alter('bulk_photo_nodes_filename', $images_count);
  if ($options['directory'] == '/') {
    $options['directory'] = '';
  }
  $destination = $options['scheme'] . $image_field->uid . '-' . $images_count . '.' . $extension;
  $image_field->filename = $image_field->uid . '-' . $images_count . '.' . $extension;
  $image_field_ref = (array) file_move($image_field, $destination, FILE_EXISTS_REPLACE);

  foreach ($node_fields['right']['node'] as $field_name => $field_values) {
    // Iterate through fields. Convert form values to properties of the node.
    if ($field_name == $image_field_name) {
      continue;
    }
    if ($field_name != 'title') {
      $field_info = field_info_field($field_name);
      // Check if field is empty.
      $empty_function = $field_info['module'] . '_field_is_empty';
      $is_empty = TRUE;
      if (function_exists($empty_function)) {
        $items = field_get_items('node', $node, $field_name);
        if (is_array($items)) {
          foreach ($items as $item) {
            if (!$empty_function($item, $field_name)) {
              $is_empty = FALSE;
            }
          }
        }
        elseif (!is_array($items) && !empty($items)) {
          if (!$empty_function($items, $field_name)) {
            $is_empty = FALSE;
          }
        }
      }
    }
    else {
      $is_empty = empty($field_values);
    }
    if ($is_empty) {
      //The empty() language construct cannot accept function return values
      $check_empty = _bulk_photo_nodes_array_filter($node_overrides[$field_name]);
      if(!empty($check_empty)) {
        $node->$field_name = $node_overrides[$field_name];
      }
      else {
        unset($node->$field_name);
      }
    }
    else {
      $node->$field_name = $field_values;
    }
  }
  drupal_alter('bulk_photo_nodes_node', $node, $node_fields, $node_overrides);
  if (!isset($node->path)) {
    $node->path = array();
  }
  $node->path['pathauto'] = TRUE;
  node_save($node);
  return (!empty($node->nid)) ? TRUE : FALSE;
}

/**
 * Gets configuration options of the image field used by bulk_photo_nodes.
 *
 * @param string $node_type
 *   The machine of the content type used by bulk_photo_nodes.
 *
 * @return array
 *   Various configuration options for the image field used.
 */
function bulk_photo_nodes_get_file_info($node_type) {
  $options = array();
  $options['field_name'] = bulk_photo_nodes_get_image_field($node_type);
  $options['field_info'] = field_info_field($options['field_name']);
  $options['instance_info'] = field_info_instance('node', $options['field_name'], $node_type);
  $options['scheme'] = $options['field_info']['settings']['uri_scheme'] . '://';
  $options['directory'] = $options['instance_info']['settings']['file_directory'] . '/';
  return $options;
}

/**
 * Adds an #ajax property recursively to all elements of a form.
 *
 * @param array $element
 *   The first element to recursively apply #ajax to.
 */
function bulk_photo_nodes_recursive_ajax(&$element) {
  if (element_children($element)) {
    foreach (element_children($element) as $child) {
      bulk_photo_nodes_recursive_ajax($element[$child]);
    }
    if (isset($element['#ajax']) && is_array($element['#ajax'])) {
      $element['#ajax'][] = array(
        'event' => 'change',
        'wrapper' => 'bpn-nodes',
        'callback' => 'bulk_photo_nodes_add_form_ajax',
        'method' => 'replace',
        'progress' => array('type' => 'none'),
      );
    }
    else {
      $element['#ajax'] = array(
        'event' => 'change',
        'wrapper' => 'bpn-nodes',
        'callback' => 'bulk_photo_nodes_add_form_ajax',
        'method' => 'replace',
        'progress' => array('type' => 'none'),
      );
    }
    if (!empty($element['#autocomplete_path'])) {
      $element['#element_validate'] = array('bulk_photo_nodes_taxonomy_autocomplete_validate');
    }
    elseif (!empty($element['#type']) && $element['#type'] == 'select') {
      if (!empty($element['#value_key']) && $element['#value_key'] == 'tid') {
        $element['#element_validate'] = array('bulk_photo_nodes_taxonomy_validate');
      }
    }
  }
  else {
    $element['#ajax'] = array(
      'event' => 'change',
      'wrapper' => 'bpn-nodes',
      'callback' => 'bulk_photo_nodes_add_form_ajax',
      'method' => 'replace',
      'progress' => array('type' => 'none'),
    );
    if (!empty($element['#autocomplete_path'])) {
      // Add custom validation for autocomplete taxonomy textfields.
      $element['#element_validate'] = array('bulk_photo_nodes_taxonomy_autocomplete_validate');
    }
    elseif (!empty($element['#type']) && $element['#type'] == 'select') {
      // Add custom validation for taxonomy selects.
      if (!empty($element['#value_key']) && $element['#value_key'] == 'tid') {
        $element['#element_validate'] = array('bulk_photo_nodes_taxonomy_validate');
      }
    }
  }
}

/**
 * Sets the #required to FALSE recurvisely to all elements of a form.
 *
 * @param array $element
 *   The first element to recursively set #required = FALSE.
 */
function bulk_photo_nodes_recursive_set_optional(&$element) {
  if (!$element) {
    return;
  }
  if (isset($element['#required'])) {
    $element['#required'] = FALSE;
    $element['#element_validate'] = array();
  }
  $children = element_children($element);
  if ($children) {
    foreach ($children as $child) {
      bulk_photo_nodes_recursive_set_optional($element[$child]);
    }
  }
}

/**
 * Sets the #required to FALSE recurvisely to all elements of a form.
 *
 * @param array $element
 *   The first element to recursively set #required = FALSE.
 */
function bulk_photo_nodes_recursive_set_required(&$element) {
  if (!$element) {
    return;
  }
  if (isset($element['#required'])) {
    $element['#required'] = TRUE;
  }
  $children = element_children($element);
  if ($children) {
    foreach ($children as $child) {
      bulk_photo_nodes_recursive_set_required($element[$child]);
    }
  }
}

/**
 * Checks if given element is required.
 *
 * @param array $element
 *   The first element to recursively check for #required = TRUE.
 */
function bulk_photo_nodes_is_required(&$element) {
  if (!$element) {
    return FALSE;
  }
  if (isset($element['#required']) && $element['#required']) {
    return TRUE;
  }
  $children = element_children($element);
  if ($children) {
    foreach ($children as $child) {
      if (bulk_photo_nodes_is_required($element[$child])) {
        return TRUE;
      }
    }
  }
  return FALSE;
}

/**
 * Validates taxonomy autocomplete terms.
 */
function bulk_photo_nodes_taxonomy_autocomplete_validate(&$element, &$form_state) {
  $value = array();
  if ($tags = $element['#value']) {
    // Collect candidate vocabularies.
    $field_info = field_info_field($element['#field_name']);
    $field_instance = field_info_instance($element['#entity_type'], $element['#field_name'], $element['#bundle']);
    $vocabularies = array();
    foreach ($field_info['settings']['allowed_values'] as $tree) {
      if ($vocabulary = taxonomy_vocabulary_machine_name_load($tree['vocabulary'])) {
        $vocabularies[$vocabulary->vid] = $vocabulary;
      }
    }

    // Translate term names into actual terms.
    $typed_terms = drupal_explode_tags($tags);
    foreach ($typed_terms as $typed_term) {
      // See if the term exists in the chosen vocabulary and return the tid;
      // otherwise, create a new 'autocreate' term for insert/update.
      if ($possibilities = taxonomy_term_load_multiple(array(), array('name' => trim($typed_term), 'vid' => array_keys($vocabularies)))) {
        $term = array_pop($possibilities);
      }
      else {
        $vocabulary = reset($vocabularies);
        $term = array(
          'tid' => 'autocreate',
          'vid' => $vocabulary->vid,
          'name' => $typed_term,
          'vocabulary_machine_name' => $vocabulary->machine_name,
        );
      }
      $value[] = (array) $term;
    }
  }
  form_set_value($element, $value, $form_state);
}

/**
 * Validates selected taxonomy terms.
 */
function bulk_photo_nodes_taxonomy_validate(&$element, &$form_state) {
  if ($element['#value'] !== '_none') {
    $term = array(
      0 => array(
        'tid' => $element['#value'],
      ),
    );
  }
  else {
    $term = 0;
  }
  form_set_value($element, $term, $form_state);
}

/**
 * Checks if a given field form element has a value.
 *
 * @param string $field_name
 *   The name of the field to check.
 *
 * @param object $node
 *   The node object to check values against.
 *
 * @return bool
 *   TRUE if the field has a value, otherwise FALSE.
 */
function bulk_photo_nodes_check_field_empty($field_name, $node) {
  $field_info = field_info_field($field_name);
  $empty_function = $field_info['module'] . '_field_is_empty';
  $field_has_value = FALSE;
  if (function_exists($empty_function)) {
    $field_items = field_get_items('node', $node, $field_name);
    if (is_array($field_items)) {
      // Multi-value field.
      foreach ($field_items as $item) {
        if (!$empty_function($item, $field_name)) {
          $field_has_value = TRUE;
        }
      }
    }
    elseif (!is_array($field_items) && !empty($field_items)) {
      // String/numeric value.
      if (!$empty_function($field_items, $field_name)) {
        $field_has_value = TRUE;
      }
      else {
        $field_has_value = FALSE;
      }
    }
  }
  return $field_has_value;
}

/**
 * Sets and returns the current form step form id.
 *
 * @param string $chosen_form
 *   The form ID of the current step.
 *
 * @return string
 *   The form ID of the current step.
 */
function bulk_photo_nodes_chosen_form($chosen_form = NULL) {
  $form_id = &drupal_static(__FUNCTION__);
  if (isset($chosen_form)) {
    $form_id = $chosen_form;
  }
  return $form_id;
}

/**
 * Recursively removes empty values from an array. Helper function for saving
 * nodes.
 *
 * @param array $input
 *   The array to filter.
 */
function _bulk_photo_nodes_array_filter($input) {
  if(is_array($input)) {
    foreach ($input as &$value) {
      if (is_array($value)) {
        $value = _bulk_photo_nodes_array_filter($value);
      }
    }
    return array_filter($input);
  }
  else {
    return false;
  }
}