modules/taxonomy_csv/taxonomy_csv.api.inc

<?php
// $Id: taxonomy_csv.api.inc,v 2.3 2009/10/05 09:43:12 danielkm Exp $

/**
 * @file
 * This API allows to use taxonomy_csv import/export functions from other module.
 *
 * Functions sets:
 * 1a. Prepare and import a vocabulary      : taxonomy_csv_vocabulary_import
 * 1b. Prepare and export a vocabulary      : taxonomy_csv_vocabulary_export
 * 2a. Prepare and import a line            : taxonomy_csv_line_import
 * 2b. Prepare and export a line from a term: taxonomy_csv_line_export
 * 3. Prepare and import a term             : taxonomy_csv_term_import
 * 4. Errors helpers
 * 5. Infos and log messages
 *
 *
 * Structure of import api:
 * -  1. Batch prepare import of file or text
 * -  2. Process import line by line (see below)
 * -  3. Evaluate vocabulary and finish process
 *
 * Process import structure (line by line import from a batch set):
 * - 1. Validate line
 *     1. Clean input line
 *     2. Check line items
 * - 2. Prepare to process items matching import type (eventual loop)
 * - 3. Process import
 *     1. Find previous or existing term (see below)
 *     2. Update or create term
 *     3. Cache term
 *
 * Find a term before update or create it:
 * - 1. In previous imported
 *     1. In parent if structure
 *     2. In whole cache in all cases
 *     3. In extended cache if related (internal use only)
 * - 2. In existing terms of the vocabulary (except ignore all)
 *     1. In parent if structure
 *     2. In whole vocabulary in all cases
 *     3. In all vocabularies if related (internal use only)
 *
 *
 * Structure of export api:
 * - 1. Batch prepare of vocabulary
 * - 2. Export depending on format
 *
 *
 * To add a new csv scheme, need:
 * - a define without space,
 * - items in _taxonomy_csv_info_lists,
 * - items in taxonomy_csv.js and taxonomy_csv.css,
 * - a description in forms (taxonomy_csv.module),
 * - an advanced help.
 * - a case in _taxonomy_csv_check_items(),
 * - a case in taxonomy_csv_import_line_items(),
 * - eventually specific options.
 * - a case in taxonomy_csv_export_line_items() if possible,
 */

/**
 * Available import/export schemas.
 */
define('TAXONOMY_CSV_FORMAT_ALONE_TERMS',       'alone_terms');
define('TAXONOMY_CSV_FORMAT_FIELDS_LINKS',      'fields_links');
define('TAXONOMY_CSV_FORMAT_FLAT',              'flat');
define('TAXONOMY_CSV_FORMAT_TREE_STRUCTURE',    'tree_structure');
define('TAXONOMY_CSV_FORMAT_POLYHIERARCHY',     'polyhierarchy');
define('TAXONOMY_CSV_FORMAT_PARENTS',           'parents');
define('TAXONOMY_CSV_FORMAT_CHILDREN',          'children');
define('TAXONOMY_CSV_FORMAT_FIELDS',            'fields');
define('TAXONOMY_CSV_FORMAT_RELATIONS',         'relations');
define('TAXONOMY_CSV_FORMAT_DESCRIPTIONS',      'descriptions');
define('TAXONOMY_CSV_FORMAT_WEIGHTS',           'weights');
define('TAXONOMY_CSV_FORMAT_SYNONYMS',          'synonyms');
define('TAXONOMY_CSV_FORMAT_TAXONOMY_MANAGER',  'taxonomy_manager');

/**
 * Available import options.
 */
define('TAXONOMY_CSV_EXISTING_UPDATE',          'update'); // When no difference between merge and replace.
define('TAXONOMY_CSV_EXISTING_UPDATE_MERGE',    'update_merge');
define('TAXONOMY_CSV_EXISTING_UPDATE_REPLACE',  'update_replace');
define('TAXONOMY_CSV_EXISTING_IGNORE',          'ignore'); // When no difference between create and all. Equal to duplicate.
define('TAXONOMY_CSV_EXISTING_IGNORE_CREATE',   'ignore_create');
define('TAXONOMY_CSV_EXISTING_IGNORE_ALL',      'ignore_all'); // Ignore even existing terms in additional columns.
define('TAXONOMY_CSV_EXISTING_IGNORE_PREVIOUS', 'ignore_previous'); // Internal only.

/**
 * List of watchdog options.
 */
define('TAXONOMY_CSV_WATCHDOG_ERROR',           3); // Stop import process.
define('TAXONOMY_CSV_WATCHDOG_WARNING',         4); // Stop line process and go to next one.
define('TAXONOMY_CSV_WATCHDOG_NOTICE',          5); // Continue current line process.
define('TAXONOMY_CSV_WATCHDOG_INFO',            6); // Successfully processed.
define('TAXONOMY_CSV_WATCHDOG_DEBUG',           7); // Internal use only.
define('TAXONOMY_CSV_WATCHDOG_NONE',            9); // Internal use only.

/**
 * Information about import process. Use too default Drupal constants:
 *   SAVED_NEW     = 1
 *   SAVED_UPDATED = 2
 * Possibly use of:
 *   SAVED_DELETED = 3
 */
define('TAXONOMY_CSV_ERROR',                    0);
define('TAXONOMY_CSV_NEW_UPDATED',              4);
define('TAXONOMY_CSV_UNCHANGED',                5);

/**
 * @defgroup taxonomy_csv_vocabulary Import/export a vocabulary
 * @{
 * Functions allowing import of a vocabulary into a new or an existing one and
 * export of a vocabulary to a file.
 */

/**
 * Prepare the import of a vocabulary.
 * If not used in a form, don't forget to use batch_process().
 *
 * @param $options
 *   Array of options:
 *     source_choice  : 'path', 'url' or 'text'
 *     path           : path to local csv file
 *     url            : url to distant or local csv file
 *     file           : object file if file is already uploaded
 *     text           : csv text to import
 *     import_format  : see _taxonomy_csv_info_lists('list_import_format')
 *     delimiter      : one character csv delimiter (default: ",")
 *     enclosure      : zero or one character csv enclosure (default: none, i.e. '"')
 *     vocabulary_target: 'autocreate' (default), 'duplicate' or 'existing'
 *     vocabulary_id  : vocabulary id to duplicate or to import into
 *     existing_items : see _taxonomy_csv_info_lists('list_import_option')
 *     relations_create_subrelations: boolean. Specific to related terms import
 *     relations_all_vocabularies   : boolean. Id
 *     internal_cache : boolean. tweak to use (default) or not internal cache
 *     hierarchy_check: boolean. tweak to check (default) or not hierarchy of vocabulary
 *     hierarchy_level: if hierarchy_check is false, set hierarchy level (0, 1 or 2)
 *     line_checks    : boolean. tweak to check (default) or not format of lines
 *     utf8_check     : boolean. tweak to check (default) or not utf8 format
 *     result_stats   : boolean. Display (default) or not stats
 *     result_terms   : boolean. Display (default) or not list of imported terms
 *     result_level   : Log level: 'none', 'warnings' (default), 'notices' or 'infos'
 *     result_type    : Display of log: 'by_message' (default) or 'by_line'
 *   Needed options are source_choice, path or url or text, import_format and existing_items.
 * @return
 *   Array of errors or nothing (batch process to execute).
 */
function taxonomy_csv_vocabulary_import($options) {
  // Check and eventually update options.
  $result = _taxonomy_csv_vocabulary_import_check_options($options);
  if (count($result)) {
    return $result;
  }

  // Remove useless option, because text is saved.
  if ($options['source_choice'] == 'text') {
    $options['text'] = '';
  }

  // Calculates number of lines to be imported.
  // Automatically detects line endings.
  ini_set('auto_detect_line_endings', '1');
  $handle = fopen($options['file']->filepath, 'r');
  $lines_count = 0;
  while (fgetcsv($handle, 32768, $options['delimiter'], $options['enclosure'])) {
    $lines_count++;
  }
  fclose($handle);
  $options['total_lines'] = $lines_count;
  if (!$options['total_lines']) {
    return array('source_choice' => t('No term to import. Import finished.'));
  }

  // Prepare vocabularies.
  // If source is fields_links, check and eventual creation of vocabularies are made each line.
  if ($options['import_format'] != TAXONOMY_CSV_FORMAT_FIELDS_LINKS) {
    // User choose to autocreate or duplicate a vocabulary.
    switch ($options['vocabulary_target']) {
      case 'autocreate':
        $new_vocabulary = taxonomy_csv_vocabulary_create(($options['source_choice'] != 'text') ? $options['file']->filename : '');
        $options['vocabulary_id'] = $new_vocabulary['vid'];
        break;

      case 'duplicate':
        $new_vocabulary = taxonomy_csv_vocabulary_duplicate($options['vocabulary_id']);
        $options['vocabulary_id'] = $new_vocabulary['vid'];
        break;
    }
    $options['vocabulary'] = taxonomy_vocabulary_load($options['vocabulary_id']);
  }

  // Prepare import batch.
  $batch = array(
    'title'            => ($options['source_choice'] != 'text') ?
        t('Importing terms from CSV file "%filename"...', array('%filename' => $options['file']->filename)) :
        t('Importing terms from text...'),
    'init_message'     => t('Starting uploading of datas...'),
    'progress_message' => '',
    'error_message'    => t('An error occurred during the import.'),
    'finished'         => '_taxonomy_csv_vocabulary_import_finished',
    'file'             => dirname(drupal_get_filename('module', 'taxonomy_csv')) .'/taxonomy_csv.api.inc',
    'progressive'      => TRUE,
    'operations'       => array(
      0 => array('_taxonomy_csv_vocabulary_import_process', array($options)),
    ),
  );

  batch_set($batch);
}

/**
 * Validate options of imported vocabulary or line.
 *
 * @param $options
 *   Array of options.
 * @return
 *   Array of messages errors if any.
 *   By reference options are cleaned and completed.
 */
function _taxonomy_csv_vocabulary_import_check_options(&$options) {
  $messages = array();

  // Set default value for unset options.
  foreach (array(
      'delimiter'          => ',',
      'enclosure'          => '',
      'vocabulary_target'  => 'autocreate',
      'internal_cache'     => TRUE,
      'hierarchy_check'    => TRUE,
      'line_checks'        => TRUE,
      'utf8_check'         => TRUE,
      'result_stats'       => 'result_stats',
      'result_terms'       => 'result_terms',
      'result_level'       => 'notices',
      'result_type'        => 'by_message',
      // Default options of specific imports.
      'relations_create_subrelations' => FALSE,
      'relations_all_vocabularies'    => FALSE,
    ) as $key => $value) {
    if (!isset($options[$key])) {
      $options[$key] = $value;
    }
  }

  // Check if there is write access and prepare file.
  switch ($options['source_choice']) {
    case 'path':
    case 'url':
      // Upload if not already uploaded.
      if (!isset($options['file'])) {
        // Upload from a path.
        if ($options['source_choice'] == 'path') {
          $options['file'] = file_save_upload($options['path']);
        }
        // Upload from an url.
        else {
          $filename = file_save_data(
            file_get_contents($options['url']),
            basename($options['url']),
            'FILE_EXISTS_RENAME');
          $options['file'] = new stdClass();
          $options['file']->filename = basename($filename);
          $options['file']->filepath = $filename;
          $options['file']->filesize = filesize($filename);
        }
      }

      if (!$options['file']) {
        $messages['path'] = t("You choose to import a taxonomy by a file, but you don't set its name or its size is greater than the server's limit of !max_size.", array('!max_size' => format_size(parse_size(ini_get('upload_max_filesize')))));
      }
      elseif (!$options['file']->filesize) {
        $messages['path'] = t('Size of your file is null.');
      }
      break;

    case 'text':
      if (empty($options['text'])) {
        $messages['text'] = t('You choose to import a taxonomy by a text, but the text is empty.');
      }
      elseif (!isset($options['file'])) {
        // Prepare import by text: save text as a temp file to simplify process and avoid memory congestion.
        $filename = file_save_data(
          $options['text'],
          'taxo_csv',
          'FILE_EXISTS_RENAME');
        $options['file'] = new stdClass();
        $options['file']->filename = basename($filename);
        $options['file']->filepath = $filename;
        $options['file']->filesize = filesize($filename);

        if (!$filename) {
          $messages['text'] = t('Import by text needs access to temp directory. Import failed.');
        }
      }
      break;

    default:
      $messages['source_choice'] = t('Source choice should be "path", "url" or "text".');
  }

  // Delimiter and enclosure greater than one character are useless with fgetcsv.
  if (drupal_strlen($options['delimiter']) != 1) {
    $messages['delimiter'] = t('Delimiter should be a one character string.');
  }
  if (drupal_strlen($options['enclosure']) == 0) {
    // With fgetcsv, $enclosure == '' bugs, so use default quote enclosure if none.
    $options['enclosure'] = '"';
  }
  elseif (drupal_strlen($options['enclosure']) > 1) {
    $messages['enclosure'] = t('Enclosure lenght cannot be greater than one character.');
  }
  if ($options['delimiter'] == $options['enclosure']) {
    $messages['delimiter'] = t('Delimiter and enclosure cannot be same character.');
  }

  if (!in_array($options['vocabulary_target'], array(
      'autocreate',
      'duplicate',
      'existing',
    ))) {
    $messages['vocabulary_target'] = t('Destination target should be "autocreate", "duplicate" or "existing".');
  }

  if ($options['vocabulary_target'] == 'duplicate'
      || $options['vocabulary_target'] == 'existing') {
    $list_vocabularies = taxonomy_get_vocabularies();
    if (!isset($list_vocabularies[$options['vocabulary_id']])) {
      $messages['vocabulary_id'] = t("You choose to use an existing vocabulary, but you haven't choose it.");
    }
  }

  $list_import_format = _taxonomy_csv_info_lists('list_import_format');
  $list_import_option = _taxonomy_csv_info_lists('list_import_option');
  $list_import_format_allowed_import_option = _taxonomy_csv_info_lists('list_import_format_allowed_import_option');
  if (!array_key_exists($options['import_format'], $list_import_format)) {
    $messages['import_format'] = t('Source content "!import_format" is not managed.', array(
      '!import_format' => $list_import_format[$options['import_format']]
    ));
  }
  elseif (!in_array($options['existing_items'], $list_import_format_allowed_import_option[$options['import_format']])) {
    $messages['existing_items'] = t('Import option "%existing_items" cannot be used with source content "!import_format".', array(
      '%existing_items' => $list_import_option[$options['existing_items']],
      '!import_format'  => $list_import_format[$options['import_format']],
    ));
  }

  if (!$options['existing_items']) {
    $messages['existing_items'] = t('Please set what will become existing terms.');
  }
  elseif (!array_key_exists($options['existing_items'], $list_import_option)) {
    $messages['existing_items'] = t('Import option "!existing_items" is not managed.', array(
      '!existing_items' => $list_import_option[$options['existing_items']]
    ));
  }

  if ($options['hierarchy_check']
      && ($options['hierarchy_level'] < 0 || $options['hierarchy_level'] > 2)) {
    $messages['hierarchy_level'] = t('You need to set hierarchy level if hierarchy check of vocabulary is disabled.');
  }

  // Advertise if Pathauto module is activated. Issue http://drupal.org/node/540916.
  if (module_exists('pathauto')) {
    $messages['pathauto'] = t("<strong>Warning</strong>: Pathauto module is activated.<br />
      This module slows down taxonomy import process and only few terms can be imported. It's advised to disabled it manually in !modules_section. Settings aren't lost when you disable it - and not uninstall it -.<br />
      After import process, you can reactivate Pathauto and eventually bulk generate aliases for newly imported terms.", array(
        '!modules_section' => l(t('modules section'), 'admin/build/modules'),
    ));
  }

  return $messages;
}

/**
 * Batch process of vocabulary import.
 *
 * @param $options
 *   Array of batch options.
 * @param &$context
 *   Batch context to keep results and messages.
 * @return
 *   NULL because use of &$context.
 */
function _taxonomy_csv_vocabulary_import_process($options, &$context) {
  $first = FALSE;

  // First callback.
  if (empty($context['sandbox'])) {
    // Remember options as batch_set can't use form_storage.
    // It allows too that first line in result is numbered 1 and not 0.
    $context['results'][0] = $options;

    $first = TRUE;

    // Automatically detect line endings.
    ini_set('auto_detect_line_endings', '1');

    // Initialize some variables.
    $context['results'][0]['current_line'] = 0;
    $context['results'][0]['worst_line'] = 0;
    $context['results'][0]['worst_message'] = 999;
    $context['results'][0]['handle'] = fopen($options['file']->filepath, 'r');
    $context['sandbox']['handle_pointer'] = 0;
    $context['sandbox']['max'] = $options['total_lines'];
    $context['sandbox']['previous_items'] = array(
      'name' => array(),
      'tid'  => array(),
    );

    // Enable or disable cache.
    $result = _taxonomy_csv_term_cache($options['internal_cache'], 'use_cache');
  }
  elseif (!is_resource($context['results'][0]['handle'])) {
    // Recall file and set pointer in case of memory or time out.
    $context['results'][0]['handle'] = fopen($options['file']->filepath, 'r');
    fseek($context['results'][0]['handle'], $context['sandbox']['handle_pointer']);

    // Reload internal static cache if it has been removed in case of long batch.
    if ($options['internal_cache']
        && isset($context['results'][0]['imported_terms'])
        && (_taxonomy_csv_term_cache('', 'count') == 0)) {
      $result = _taxonomy_csv_term_cache($context['results'][0]['imported_terms'], 'set_cache');
    }
  }

  // Load and process one line.
  $worst_line     = &$context['results'][0]['worst_line'];
  $worst_message  = &$context['results'][0]['worst_message'];
  $handle         = &$context['results'][0]['handle'];
  $line_number    = &$context['results'][0]['current_line'];
  $previous_items = &$context['sandbox']['previous_items'];
  $line = fgetcsv($handle, 32768, $options['delimiter'], $options['enclosure']);
  if ($line) {
    $line_number++;

    // Remember pointer in case of memory or time out.
    $context['sandbox']['handle_pointer']  = ftell($handle);

    // Skip eventual UTF-8 byte order mark.
    if ($first) {
      if (strncmp($line[0], "\xEF\xBB\xBF", 3) === 0) {
        $line[0] = substr($line[0], 3);
        $first = FALSE;
      }
    }

    // Process import of current line.
    $result = taxonomy_csv_line_import($line, $options, $previous_items);

    // Remember processed line.
    $previous_items['name'] = $result['name'];
    $previous_items['tid']  = $result['tid'];

    // Remember worst message of imported lines.
    $worst_message_new = _taxonomy_csv_message_get_worst_message($result['msg']);
    if ($worst_message_new < $worst_message) {
      $worst_message = $worst_message_new;
      $worst_line    = $line_number;
    };

    if ($options['internal_cache']) {
      // Remember only wanted logs.
      switch ($options['result_level']) {
        case 'none':
          break;
        case 'warnings':
          $list_messages = array();
          foreach ($result['msg'] as $value) {
            foreach ($value as $msg) {
              if (_taxonomy_csv_message_get_level($msg) <= TAXONOMY_CSV_WATCHDOG_WARNING) {
                $list_messages[$msg] = $msg;
              }
            }
          }
          if (count($list_messages)) {
            sort($list_messages);
            $context['results'][$line_number] = $list_messages;
          }
          break;
        case 'notices':
          $list_messages = array();
          foreach ($result['msg'] as $value) {
            foreach ($value as $msg) {
              if (_taxonomy_csv_message_get_level($msg) <= TAXONOMY_CSV_WATCHDOG_NOTICE) {
                $list_messages[$msg] = $msg;
              }
            }
          }
          sort($list_messages);
          $context['results'][$line_number] = $list_messages;
          break;
        case 'infos':
          $list_messages = array();
          foreach ($result['msg'] as $value) {
            foreach ($value as $msg) {
              $list_messages[$msg] = $msg;
            }
          }
          sort($list_messages);
          $context['results'][$line_number] = $list_messages;
          break;
        case 'full':
          $context['results'][$line_number] = $result;
          break;
      }

      // Save static cache to keep informations about process in case of batch timeout.
      $context['results'][0]['imported_terms'] =& _taxonomy_csv_term_cache('', 'dump');
    }

    // Inform about progress.
    $context['message'] = t('Line !line_number of !total_lines processed: !line', array(
      '!line_number' => $line_number,
      '!total_lines' => $options['total_lines'],
      // $previous_items['name'] can be used, except with taxonomy_manager format.
      '!line'        => implode(', ', $line),
    ));

    // Check worst message of imported lines and update progress.
    if (_taxonomy_csv_message_get_level($worst_message) > TAXONOMY_CSV_WATCHDOG_ERROR) {
      $context['finished'] = $line_number / $context['sandbox']['max'];
    }
    else {
      $context['finished'] = 1;
      if ($options['internal_cache']) {
        $result = _taxonomy_csv_term_cache('', 'clear');
      }
    }
  }
  // Keep last previous items with fields_links in order to check vocabulary.
  if ($options['import_format'] == TAXONOMY_CSV_FORMAT_FIELDS_LINKS) {
    $context['results'][0]['last_items'] = $previous_items;
  }
}

/**
 * Callback for finished batch import and display result informations.
 */
function _taxonomy_csv_vocabulary_import_finished($success, $results, $operations) {
  // $results[0] is used to save options and some infos (imported terms), as batch process can't use $form_state.
  $options = &$results[0];
  unset($results[0]);

  // Close imported file.
  if ($options['handle']) {
    fclose($options['handle']);
  }

  // Clear internal cache.
  if ($options['internal_cache']) {
    $result = _taxonomy_csv_term_cache('', 'clear');
  }

  // Display general info.
  drupal_set_message(_taxonomy_csv_info_chosen_options($options), 'status');

  // Check and info on used or created vocabularies.
  $vocabularies = ($options['import_format'] == TAXONOMY_CSV_FORMAT_FIELDS_LINKS) ?
      $options['last_items']['tid']['vocabulary'] :
      array($options['vocabulary_id']);
  $message = t('!count used or created.', array('!count' => format_plural(count($vocabularies), 'A vocabulary has been', '@count vocabularies have been')));
  drupal_set_message($message, 'status');
  foreach ($vocabularies as $vocabulary_id) {
    // Check and update hierarchy of vocabularies.
    $vocabulary = taxonomy_vocabulary_load($vocabulary_id);
    $new_hierarchy[$vocabulary_id] = ($options['hierarchy_check']) ?
        taxonomy_csv_vocabulary_check_hierarchy($vocabulary_id) :
        taxonomy_csv_vocabulary_check_hierarchy($vocabulary_id, $options['hierarchy_level']);

    // Display general info about vocabulary.
    $message = ($options['import_format'] == TAXONOMY_CSV_FORMAT_FIELDS_LINKS) ?
        t('Vocabulary "%vocabulary_name" has been used or created.', array('%vocabulary_name' => $vocabulary->name)) :
        _taxonomy_csv_info_vocabulary_destination($vocabulary, $options['vocabulary_target']);
    $message .=  '<br />';
    $message .= _taxonomy_csv_info_vocabulary_result($vocabulary, $options['vocabulary_target'], $new_hierarchy[$vocabulary_id]) .'<br />';
    if (!$options['hierarchy_check']) {
      $message .= t('Hierarchy level has been manually set.') .'<br />';
    }
    drupal_set_message($message, 'status');
  }

  // Prepare batch result message.
  if (!$success) {
    $message = t('Importation failed');
    $message .= '<br />'. t('This issue is related to import process or to size import and probably not to content.');
    if ($options['current_line'] == $options['total_lines']) {
      $message .= '<br />'. t('Import process was successful, but the evaluation of hierarchy level has failed, because it is highly memory consumming. You need to change its value with default Drupal functions or set it in Tweaks section of Taxonomy csv.') .' '. t('This problem can be caused too by a high log level. You can reduce it in advanced options.');
    }
    else {
      $message .= '<br />'. t('Import process was successful until the line !line_count of a total of !total_lines. You can first check your file on this line and check file uploading.', array(
        '!line_count'  => $options['current_line'],
        '!total_lines' => $options['total_lines'],
      ));
    }
    $message .= '<br />'. t('You can reduce log level or disable internal cache to avoid this error.');
    $message .= '<br />'. t('You can reinstall module from a fresh release or submit an issue on <a href="!link">Taxonomy CSV import/export module</a>.', array(
      '!link' => url('http://drupal.org/project/issues/taxonomy_csv/'),
    ));

    drupal_set_message($message, 'error');
  }
  else {
    // Short summary information.
    switch (_taxonomy_csv_message_get_level($options['worst_message'])) {
      case TAXONOMY_CSV_WATCHDOG_ERROR:
        drupal_set_message(t('Errors have been reported during import process. Process failed at line !line_number with error: !message', array(
          '!line_number' => $options['worst_line'],
          '!message'     => _taxonomy_csv_info_result_text($options['worst_message']),
        )), 'error');
        break;
      case TAXONOMY_CSV_WATCHDOG_WARNING:
        drupal_set_message(t('Warnings have been reported during import process (bad formatted lines). First line skipped is line !line_number with message: !message', array(
          '!line_number' => $options['worst_line'],
          '!message'     => _taxonomy_csv_info_result_text($options['worst_message']),
        )), 'error');
        break;
      case TAXONOMY_CSV_WATCHDOG_NOTICE:
        drupal_set_message(t('Notices have been reported during import process (bad formatted or empty lines). Lines processed. First notice on line !line_number with message: !message', array(
          '!line_number' => $options['worst_line'],
          '!message'     => _taxonomy_csv_info_result_text($options['worst_message']),
        )), 'warning');
        break;
      case TAXONOMY_CSV_WATCHDOG_INFO:
      default:
        drupal_set_message(t('No error, warnings or notices have been reported during import process.'), 'status');
        break;
    }

    if (!$options['line_checks']) {
      drupal_set_message(t('Line checks have been disabled. Some warnings and notices may have not been reported.'), 'warning');
    }

    if (!$options['internal_cache']) {
      drupal_set_message(t('No more information about process because internal cache is disabled.'), 'notice');
    }
    else {
      // Display stats and eventually lists about imported terms.
      if ($options['result_stats'] || $options['result_terms']) {
        if (isset($options['imported_terms'])) {
          if ($options['result_terms']) {
            drupal_set_message(_taxonomy_csv_info_terms_stats($options['imported_terms'], 'full'), 'status');
          }
          elseif ($options['result_stats']) {
            drupal_set_message(_taxonomy_csv_info_terms_stats($options['imported_terms'], 'stats'), 'status');
          }
        }
        else {
          drupal_set_message(t('No term was imported.'), 'warning');
        }
      }

      // Display detailled result of import.
      if ($options['result_level'] != 'none') {
        if (count($results)) {
          drupal_set_message(t('Available informations about lines import.'));
          call_user_func("_taxonomy_csv_info_result_{$options['result_type']}", $results, $options['result_level']);
        }
        else {
          drupal_set_message(t('No more information reported about lines import.'));
        }
      }
    }
  }
}

/**
 * Prepare the export of a vocabulary.
 * If not used in a form, don't forget to use batch_process().
 *
 * @param $options
 *   Array of options:
 *     export_format: see _taxonomy_csv_info_lists('list_export_format')
 *     vocabulary_id: vocabulary id to export (default: 0, which means all)
 *     delimiter    : one character csv delimiter (default: ",")
 *     enclosure    : zero or one character csv enclosure (default: "")
 *     line_ending  : end of line character: 'Unix' (default), 'Mac' or 'Microsoft DOS'
 *     order        : order of exported terms: 'name' (default), 'tid' or 'weight'
 *     fields_links_terms_ids       : specific to fields_links: 'name_if_needed' (default), 'name', 'tid'
 *     fields_links_vocabularies_ids: specific to fields_links: 'none' (default), 'name', 'vid'
 *   Only export_format is needed.
 * @return
 *   Array of errors or nothing (batch process to execute).
 */
function taxonomy_csv_vocabulary_export($options) {
  // Check and eventually update options.
  $result = _taxonomy_csv_vocabulary_export_check_options($options);
  if (count($result)) {
    return $result;
  }

  // Csv variables.
  $options['separator']   = $options['enclosure'] . $options['delimiter'] . $options['enclosure'];
  $line_ending = array(
    'Unix'             => "\n",
    'Mac'              => "\r",
    'Microsoft DOS'    => "\r\n",
  );
  $options['end_of_line'] = $line_ending[$options['line_ending']];

  // Prepare export batch.
  $batch = array(
    'title'            => t('Exporting terms to CSV file...'),
    'init_message'     => t('Starting downloading of datas...'),
    'progress_message' => '',
    'error_message'    => t('An error occurred during the export.'),
    'finished'         => '_taxonomy_csv_vocabulary_export_finished',
    'file'             => dirname(drupal_get_filename('module', 'taxonomy_csv')) .'/taxonomy_csv.api.inc',
    'progressive'      => TRUE,
    'operations'       => array(
        0 => array('_taxonomy_csv_vocabulary_export_process', array($options))
    ),
  );

  batch_set($batch);
}

/**
 * Validate options of exported vocabulary or line.
 *
 * @param $options
 *   Array of options.
 * @return
 *   Array of messages errors if any.
 *   By reference options are cleaned and completed.
 */
function _taxonomy_csv_vocabulary_export_check_options(&$options) {
  $messages = array();

  // Set default value for unset options.
  foreach (array(
      'vocabulary_id'                 => 0,
      'delimiter'                     => ',',
      'enclosure'                     => '',
      'line_ending'                   => 'Unix',
      'order'                         => 'name',
      // Default options of specific imports.
      'fields_links_terms_ids'        => 'name_if_needed',
      'fields_links_vocabularies_ids' => 'none',
    ) as $key => $value) {
    if (!isset($options[$key])) {
      $options[$key] = $value;
    }
  }

  // Check if there is write access and prepare file (first time only).
  if (!isset($options['file'])) {
    // Set filename.
    if ($options['vocabulary_id']) {
      $vocabulary = taxonomy_vocabulary_load($options['vocabulary_id']);
      $vocabulary_name = $vocabulary->name;
    }
    else {
      $vocabulary_name = t('Taxonomy');
    }
    // Create file.
    $filename = file_save_data(
      '',
      "$vocabulary_name.csv",
      'FILE_EXISTS_RENAME');
    if (!$filename) {
      $messages['file'] = t('Export needs access to temp directory. Export failed.');
    }
    else {
      $options['file'] = new stdClass();
      $options['file']->filename = basename($filename);
      $options['file']->filepath = $filename;
      $options['file']->filesize = filesize($filename);
    }
  }

  $list_export_format = _taxonomy_csv_info_lists('list_export_format');
  if (!array_key_exists($options['export_format'], $list_export_format)) {
    $messages['export_format'] = t('Export format "!export_format" is not managed.', array(
      '!export_format' => $list_export_format[$options['export_format']],
    ));
  }

  $list_vocabularies = taxonomy_get_vocabularies();
  if (!$list_vocabularies) {
    $messages['vocabulary_id'] = t('No vocabulary to export.');
  }
  elseif ($options['vocabulary_id']) {
    if (!isset($list_vocabularies[$options['vocabulary_id']])) {
      $messages['vocabulary_id'] = t("You choose to export a vocabulary, but it doesn't exist.");
    }
  }

  // Delimiter and enclosure greater than one character are forbidden.
  if (drupal_strlen($options['delimiter']) != 1) {
    $messages['delimiter'] = t('Delimiter should be a one character string.');
  }
  if (drupal_strlen($options['enclosure']) > 1) {
    $messages['enclosure'] = t('Enclosure lenght cannot be greater than one character.');
  }
  if ($options['delimiter'] == $options['enclosure']) {
    $messages['delimiter'] = t('Delimiter and enclosure cannot be same character.');
  }

  if (!in_array($options['line_ending'], array(
      'Unix',
      'Mac',
      'Microsoft DOS',
    ))) {
    $messages['line_ending'] = t('Line ending should be "Unix", "Mac" or "Microsoft DOS".');
  }

  if (!in_array($options['order'], array(
      'name',
      'tid',
      'weight',
    ))) {
    $messages['order'] = t('Order should be "name", "tid" or "weight".');
  }

  if (!in_array($options['fields_links_terms_ids'], array(
      'name_if_needed',
      'name',
      'tid',
    ))) {
    $messages['fields_links_terms_ids'] = t('Terms identifiants should be "name_if_needed", "name" or "tid".');
  }

  if (!in_array($options['fields_links_vocabularies_ids'], array(
      'none',
      'name',
      'vid',
    ))) {
    $messages['fields_links_vocabularies_ids'] = t('Vocabularies identifiants should be "none", "name" or "vid".');
  }

  // When multiple vocabularies are exported, vocabulary names or tids is always needed.
  if ($options['fields_links_vocabularies_ids'] == 'none') {
    if ($options['vocabulary_id'] == 0) {
      $options['fields_links_vocabularies_ids'] = 'name';
    }
    else {
      // Check if all related terms are related to main vocabulary.
      ///TODO. Currently, check is made for each term in line_export.
    }
  }

  // Calculates number of terms to be exported.
  $sql = "
    SELECT COUNT(*)
    FROM {term_data}
  ";
  $args = array();
  if ($options['vocabulary_id']) {
    $sql .= ' WHERE vid = %d';
    $args[] = $options['vocabulary_id'];
  }
  $options['total_terms'] = array_shift(db_fetch_array(db_query($sql, $args)));
  if (!$options['total_terms']) {
    $message['vocabulary_id'] = t('No term to export. Export finished.');
  }

  return $messages;
}

/**
 * Batch process of vocabulary export.
 *
 * @param $options
 *   Array of batch options.
 * @param &$context
 *   Batch context to keep results and messages.
 * @return
 *   NULL because use of &$context.
 */
function _taxonomy_csv_vocabulary_export_process($options, &$context) {
  // First callback.
  if (empty($context['sandbox'])) {
    // Remember options as batch_set can't use form_storage.
    // It allows too that first line in result is numbered 1 and not 0.
    $context['results'][0] = $options;

    // Initialize some variables.
    $context['results'][0]['current_term'] = 0;
    $context['results'][0]['current_name'] = '';
    $context['results'][0]['worst_term'] = 0;
    $context['results'][0]['worst_name'] = '';
    $context['results'][0]['worst_message'] = 999;
    // No pointer because new line is appended to file.
    $context['results'][0]['handle'] = fopen($options['file']->filepath, 'a+');
    $context['sandbox']['max'] = $options['total_terms'];

    // Prepare terms to be exported.
    $sql = "
      SELECT *
      FROM {term_data}
    ";
    $args = array();
    if ($options['vocabulary_id']) {
      $sql .= ' WHERE vid = %d';
      $args[] = $options['vocabulary_id'];
    }
    // Use descendant order, because each term will be poped (quicker than shift).
    $sql .= ' ORDER BY %s DESC';
    $args[] = $options['order'];
    $result = db_query($sql, $args);
    while ($term = db_fetch_array($result)) {
      $context['sandbox']['terms'][] = $term;
    }

    // Prepare list of duplicate terms for fields_links export.
    $context['results'][0]['duplicate_terms'] = array();
    $sql = '
      SELECT t1.tid, t1.name
      FROM {term_data} t1
      LEFT OUTER JOIN {term_data} t2 ON t1.tid != t2.tid AND LOWER(t1.name) = LOWER(t2.name)
      WHERE t2.tid IS NOT NULL
    ';
    $args = array();
    if ($options['vocabulary_id']) {
      $sql .= ' AND t1.vid = %d';
      $args[] = $options['vocabulary_id'];
    }
    $sql .= '
      ORDER BY {t1.tid} ASC
    ';
    $result = db_query($sql, $args);
    while ($term = db_fetch_object($result)) {
      $context['results'][0]['duplicate_terms'][$term->tid] = $term->name;
    }
  }
  elseif (!is_resource($context['results'][0]['handle'])) {
    // Recall file in case of memory or time out. No pointer, because terms are appended.
    $context['results'][0]['handle'] = fopen($options['file']->filepath, 'a+');
  }

  // Load and process one term.
  $worst_term      = &$context['results'][0]['worst_term'];
  $worst_name      = &$context['results'][0]['worst_name'];
  $worst_message   = &$context['results'][0]['worst_message'];
  $handle          = &$context['results'][0]['handle'];
  $duplicate_terms = &$context['results'][0]['duplicate_terms'];
  $term_number     = &$context['results'][0]['current_term'];
  $current_name    = &$context['results'][0]['current_name'];
  $term = array_pop($context['sandbox']['terms']);
  if ($term) {
    $term_number++;

    // Remember current name in case of error.
    $current_name = $term['name'];

    // Process export of current term.
    $result = taxonomy_csv_line_export($term, $options, $duplicate_terms);

    // Check if separator, enclosure or line ending exist in line.
    $check_line = implode('', $result['line']);
    if ((strpos($check_line, $options['separator']) !== FALSE)
        || (($options['enclosure'] != '')
          && (strpos($check_line, $options['enclosure']) !== FALSE))
        || (($options['enclosure'] == '')
          && (strpos($check_line, $options['end_of_line']) !== FALSE))) {
      $result['msg'][] = array(313); // Error delimiter or enclosure.
    }

    // Save line to file.
    $line = $options['enclosure'] . implode($options['separator'], $result['line']) . $options['enclosure'] . $options['end_of_line'];
    if (fwrite($handle, $line) === FALSE) {
      $result['msg'][] = array(312); // Unable to write to file.
    }

    // Remember worst message of exported terms.
    $worst_message_new = _taxonomy_csv_message_get_worst_message($result['msg']);
    if ($worst_message_new < $worst_message) {
      $worst_term    = $term_number;
      $worst_name    = $current_name;
      $worst_message = $worst_message_new;
    };

    // Inform about progress.
    $context['message'] = t('Term !term_number of !total_terms processed: %term', array(
      '!term_number' => $term_number,
      '!total_terms' => $options['total_terms'],
      '%term'        => $current_name,
    ));

    // Check worst message of exported lines and update progress.
    if (_taxonomy_csv_message_get_level($worst_message) > TAXONOMY_CSV_WATCHDOG_ERROR) {
      $context['finished'] = $term_number / $context['sandbox']['max'];
    }
    else {
      $context['finished'] = 1;
    }
  }
}

/**
 * Callback for finished batch export and display result informations.
 */
function _taxonomy_csv_vocabulary_export_finished($success, $results, $operations) {
  // $results[0] is used to save options and some infos, as batch process can't use $form_state.
  $options = &$results[0];
  unset($results[0]);

  // Close exported file.
  if ($options['handle']) {
    fclose($options['handle']);
  }

  // General infos.
  $message = t('!term_count / !total_terms terms of chosen vocabularies have been exported to file <a href="!filepath">!filename</a> (!filesize KB). Click on link to view it or right click to download it.', array(
    '!term_count'  => $options['current_term'],
    '!total_terms' => $options['total_terms'],
    '!filepath'    => $options['file']->filepath,
    '!filename'    => $options['file']->filename,
    '!filesize'    => number_format(filesize($options['file']->filepath) / 1000, 1),
  )) .'<br />';
  // Main check of end process.
  $status = (($options['current_term'] == $options['total_terms']) && ($options['current_term'] > 0)) ? 'status' : 'error';
  drupal_set_message($message, $status);

  // Infos on duplicate term names.
  $duplicate_count = count($options['duplicate_terms']);
  // Duplicate term names exist. Array flip allows to display only duplicate names.
  if ($duplicate_count) {
    $message = t('!count duplicate term names have been found. Error can occur when you will import this list, except if you choose "fields and links" export format or import option "ignore existing items".', array('!count' => $duplicate_count)) .'<br />'.
    t('List of duplicate term names:') .'<br />"'.
    implode('", "', array_keys(array_flip($options['duplicate_terms']))) .'"';
    $status = 'warning';
  }
  else {
    // No duplicate term names.
    $message = t('No duplicate term name has been found.');
    $status = 'status';
  }
  drupal_set_message($message, $status);

  // Prepare batch result message.
  if (!$success) {
    $message = t('Exportation failed');
    $message .= '<br />'. t('This issue is related to export process and may be caused by a memory overrun of the database.');
    if ($options['current_term'] == $options['total_terms']) {
      $message .= '<br />'. t('All terms were exported, but a unknown error appears after the end of process.');
    }
    else {
      $message .= '<br />'. t('Export process was successful until the term !term_count (%term_name) of a total of !total_terms.', array(
        '!term_count'  => $options['current_term'],
        '%term_name'   => $options['current_name'],
        '!total_terms' => $options['total_terms'],
      ));
    }
    $message .= '<br />'. t('You can reinstall module from a fresh release or submit an issue on <a href="!link">Taxonomy CSV import/export module</a>.', array(
      '!link' => url('http://drupal.org/project/issues/taxonomy_csv/'),
    ));

    drupal_set_message($message, 'error');
  }
  else {
    // Short summary information.
    switch (_taxonomy_csv_message_get_level($options['worst_message'])) {
      case TAXONOMY_CSV_WATCHDOG_ERROR:
        drupal_set_message(t('Errors have been reported during export process. Process failed at term !worst_count (%worst_name) with error: !message', array(
          '!worst_count' => $options['worst_term'],
          '%worst_name'  => $options['worst_name'],
          '!message'     => _taxonomy_csv_info_result_text($options['worst_message']),
        )), 'error');
        break;
      case TAXONOMY_CSV_WATCHDOG_WARNING:
        drupal_set_message(t('Warnings have been reported during export process (bad formatted terms). First term skipped is term !worst_count (%worst_name) with message: !message', array(
          '!worst_count' => $options['worst_term'],
          '%worst_name'  => $options['worst_name'],
          '!message'     => _taxonomy_csv_info_result_text($options['worst_message']),
        )), 'error');
        break;
      case TAXONOMY_CSV_WATCHDOG_NOTICE:
        drupal_set_message(t('Notices have been reported during export process (bad formatted or empty terms). Terms processed. First notice on term !worst_count (%worst_name) with message: !message', array(
          '!worst_count' => $options['worst_term'],
          '%worst_name'  => $options['worst_name'],
          '!message'     => _taxonomy_csv_info_result_text($options['worst_message']),
        )), 'warning');
        break;
      case TAXONOMY_CSV_WATCHDOG_INFO:
      default:
        drupal_set_message(t('No error, warnings or notices have been reported during export process.'), 'status');
        break;
    }
  }
}

/**
 * Creates vocabulary by its name and returns an array with its vid and its name.
 */
function taxonomy_csv_vocabulary_create($vocabulary_name = '') {
  // Create an empty vocabulary. Relations and hierarchy are updated after import.
  $vocabulary = array(
    'name'         => _taxonomy_csv_vocabulary_create_name($vocabulary_name),
    'description'  => t('Auto created vocabulary by taxonomy_csv module'),
    'help'         => '',
    'relations'    => TRUE,
    'hierarchy'    => 2,
    'multiple'     => TRUE,
    'required'     => FALSE,
    'tags'         => FALSE,
    'module'       => 'taxonomy',
    'weight'       => 0,
    'nodes'        => array(),
  );

  taxonomy_save_vocabulary($vocabulary);

  return array(
    'vid' => taxonomy_csv_vocabulary_get_id($vocabulary['name']),
    'name' => $vocabulary['name'],
  );
}

/**
 * Duplicates a vocabulary by its vid and returns an array with vid and name.
 * If not exist, creates an empty vocabulary.
 */
function taxonomy_csv_vocabulary_duplicate($vocabulary_id) {
  $original_vocabulary = taxonomy_vocabulary_load($vocabulary_id);
  if ($original_vocabulary) {
    // Creates an unused name. Check if name begins with 'Copy of #name' in order to serialize name.
    $name = t('Copy of [!vocabulary_name]', array('!vocabulary_name' => $original_vocabulary->name));
    $name = _taxonomy_csv_vocabulary_create_name((strpos($original_vocabulary->name, $name) === FALSE) ? $name : $original_vocabulary->name);

    // Duplicate original vocabulary, except relations and hierarchy, updated after import.
    $duplicated_vocabulary = array(
      'name'         => $name,
      'description'  => $original_vocabulary->description,
      'help'         => $original_vocabulary->help,
      'relations'    => $original_vocabulary->relations,
      'hierarchy'    => $original_vocabulary->hierarchy,
      'multiple'     => $original_vocabulary->multiple,
      'required'     => $original_vocabulary->required,
      'tags'         => $original_vocabulary->tags,
      'module'       => $original_vocabulary->module,
      'weight'       => $original_vocabulary->weight,
      'nodes'        => array(),
    );

    taxonomy_save_vocabulary($duplicated_vocabulary);

    $duplicated_vocabulary['vid'] = taxonomy_csv_vocabulary_get_id($duplicated_vocabulary['name']);

    // Get all terms and attributes of original vocabulary
    // and copy them in the new one in two steps.
    $original_terms = taxonomy_get_tree($original_vocabulary->vid);

    // First step: copy each term except relations and parents.
    $duplicated_terms = array();
    foreach ($original_terms as $original_term) {
      $duplicated_terms[$original_term->tid] = array(
        'vid'         => $duplicated_vocabulary['vid'],
        'name'        => $original_term->name,
        'description' => $original_term->description,
        'weight'      => $original_term->weight,
        'synonyms'    => taxonomy_get_synonyms($original_term->tid),