modules/image_import/image_import.module

<?php
// $Id: image_import.module,v 1.17 2005/11/20 03:31:19 syscrusher Exp $

/**
 * image_import.module  BETA release -- not for production use
 * Maintainer: Scott Courtney (scott@4th.com) "syscrusher" on drupal.org
 *
 * This module is an adjunct to image.module by James Walker ("walkah").
 *
 * WARNING: This module calls one private function, _image_build_derivatives(),
 * from image.module. If that is deprecated or changed, this module will break.
 */

// Constants to decouple this module from changes to others
define('IMAGE_IMPORT_IMAGE_NODETYPE','image');
define('IMAGE_IMPORT_STATUS_ABORT',-1);
define('IMAGE_IMPORT_STATUS_ERROR',-2);
define('IMAGE_IMPORT_STATUS_OK',1);
define('IMAGE_IMPORT_STATUS_OK_CAPTION',2);
define('IMAGE_IMPORT_STATUS_OK_TIMEOUT',3);

/**
 * Implementation of hook_help
 */
function image_import_help($section) {
  global $user;
  global $base_url;
  switch ($section) {
    case 'admin/modules#description':
      return t('Allows mass import of images from a directory on the server.');
    case 'node/add#image_import':
      return t('Import multiple images and (optionally) captions from a directory on the web server into %site. This feature allows you to upload an entire gallery of images using FTP, SSH, or other tools, then import all of them in one step. If you are new to this feature, you may find the %helplink useful.',array('%site'=>variable_get('site_name',t('this web site')), '%helplink'=>l(t('detailed instructions'),'node/add/image_import/help')));
    case 'admin/image_import':
      return t('Image import allows users who have uploaded image (and optionally, caption) files to a directory on the server to mass-import these as image nodes.');
    case 'node/add/image_import/help':
      $path = image_import_get_import_path(TRUE);
      $upload_path = image_import_get_upload_path();
      $upload_host = preg_replace('#^\w+://(.*)/?.*$#','\1',$base_url);
      if (empty($upload_host)) {
        $upload_host = 'www.example.com';
      }
      $can_override = user_access('override image import path');
      $max_res = variable_get('upload_max_resolution','');
      $max_size = _image_import_max_upload_size();
      $res = explode('x',$max_res);
      $h_res = empty($res[0]) ? t('(unlimited)') : $res[0];
      $v_res = empty($res[1]) ? t('(unlimited)') : $res[1];
      $sizetext = $max_size ? t('may be up to %size megabytes in size', array('%size'=>$max_size))  : t('are limited in size only by the web server configuration');
      $html = '<p>' . t('This feature is designed to allow you to import many images into a gallery in one step, rather than creating them one-at-a-time. This only makes sense if the images share common attributes, such as relating to the same set of topics and being part of the same gallery or album. To create multiple galleries, you will need to repeat all the steps in these instructions for each gallery.');
      $html .= '<p>' . t('The %formlink provides specific instructions for filling in the form to do an import. This additional help explains the overall process in more detail than will fit on the import page itself.', array('%formlink'=>l(t('image import form'), 'node/add/image_import', array('title'=>t('Begin importing your images')))));
      $html .= '<p>' . t('Here are the steps for importing all the images for one gallery. This may seem complicated the first time you do it, but remember that you can import a large number of images at once, so in the long run this feature will save you a lot of time. Also, the steps become easier once you have done this a couple of times.') . '<ol>';
      $html .= '<li><p>' . t('If it does not already exist, make sure you or the site administrator create the directory &quot;%dir&quot; underneath the top-level directory for this site. If you are not the site administrator, that person will need to tell you how to access that directory for uploading your files.', array('%dir'=>$path)); 
      if ($can_override) {
        $html .= '<p>' . t(' (Your user privileges allow you to override the import directory path, but whatever directory you choose must be located underneath the top-level directory for the web site and must be readable and writeable by the web server.)');
      }
      $html .= '<li><p>' . t('Prepare your images on your personal computer or workstation, cropping, scaling, and editing them as you prefer using your choice of image editing software. (You may wish to make a copy of your originals and then edit the copy for importing to the web galleries.) The version of each image that you import should be the <em>largest size</em> that you wish to make available on the web. Do not worry about creating thumbnails or other scaled-down versions, because the import process will do that automatically for you.');
      $html .= '<p>' . t('Images on this site are limited to a maximum resolution of %h x %v (<i>horizontal</i> x <i>vertical</i>) pixels and %sizetext.', array('%h'=>$h_res, '%v'=>$v_res, '%sizetext'=>$sizetext));
      $html .= t(' The allowed file extensions for images are: %ext.', array('%ext'=>implode(', ',_image_import_img_extensions())));
      $html .= '<li><p>' . t('Optionally, add captions for some or all of your images by creating a file in the same directory with the same name as its corresponding image, but with one of the following extensions: %ext. For example, the caption for &quot;photo-0132.jpg&quot; might be &quot;photo-0132.txt&quot;.', array('%ext'=>implode(', ',_image_import_cap_extensions())));
      $html .= '<p>' . t('For each image with a caption file, the import will read the contents of that file and add it as a description for the corresponding image in the gallery. Images without captions will still be imported, but their description will be blank.');
      $html .= '<li><p>' . t('Upload all of your images and caption files to the import directory. From an FTP prompt, for example, you might need to &quot;<code>cd %updir</code>&quot; before doing &quot;<code>mput *</code>&quot; to send the files. If you use &quot;scp&quot; (part of OpenSSH) to upload, you might execute a command like this from your workstation, from the directory containing your files:<br><code>scp&nbsp;*&nbsp;%uname@%host:%updir</code>', array('%updir'=>$upload_path, '%uname'=>($user->name), '%host'=>$upload_host));
      $html .= '<li><p>' . t('Browse to the %formlink, and follow the instructions to import your images and captions.', array('%formlink'=>l(t('image import form'), 'node/add/image_import', array('title'=>t('Begin importing your images')))));
      $html .= '</ol>';
      $html .= '<p>' . t('If you are importing many images at once, or your image files are really large, you may find that the import process (the last step in the list above) causes a timeout error from the web server. If that happens, either split your gallery into smaller groups of files and import each of these groups with the same category and gallery selections, or ask your site administrator to check the PHP settings for script execution time limits.');
      // Need a trailing paragraph break in case there is site-specific guide
      // text from the main node configuration page. Drupal core will
      // automatically append that text.
      $html .= '<p>';
      return $html;
  }
}

/**
 * Implementation of hook_perm
 */
function image_import_perm() {
  return array('import images', 'import system images', 'override image import path');
}

/**
 * Implementation of hook_access
 */
function image_import_access($op, $node) {
  switch ($op) {
    case 'create':  return (user_access('import images') || user_access('import system images'));
    default:
      return NULL;
  }
}

/**
 * Dummy implementation of hook_nodeapi
 */
//function image_import_nodeapi(&$node, $op, $arg1, $arg2) {
//  return;
//}

/**
 * implentation of hook_node_info
 */
function image_import_node_info() {
  return array('image_import' => array('name' => 'image_import', 'base' => 'image_import'));
}

/**
 * Implementation of hook_settings
 */
function image_import_settings() {
  // First, check the status of the directory path and report any problems
  _image_import_check_settings(FALSE, 'image_import_default_import_path');

  $form = array();
  $form['file_path'] = array(
    '#type' => 'fieldset',
    '#title' => t('File path settings'),
    '#description' => t('These settings control the path on the server from which image and caption files will be imported. You can put the string <code>%u</code> or <code>%U</code> in the path fields, and these strings will be replaced by the username of the person doing the import. %U and %u are the same except that %U automatically removes space, %, &lt;, &gt;, *, /, \, and ? from the username.'),
    '#tree' => FALSE,
    '#collapsible' => TRUE,
    '#collapsed' => FALSE,
  );
  $form['file_path']['image_import_default_import_path'] = array(
    '#type' => 'textfield',
    '#title' => t('Default import path'),
    '#description' => t('<p>Subdirectory beneath the Drupal directory from which images may be imported in bulk. Drupal must have read/write access to this directory and subdirectories beneath it. This path must be <strong>different</strong> from the %imgsettings, which on this site is currently set to &quot;%imgpath&quot;</strong>.<p>Users with the &quot;override image import path&quot; permission can manually override this setting.', array('%imgsettings'=>l(t('image default path'), 'admin/settings/image'), '%imgpath'=>_image_import_get_image_path())),
    '#default_value' => variable_get('image_import_default_import_path','image_import/%U'),
    '#maxlength' => 50,
    '#size' => 30,
    '#required' => TRUE,
  );
  $form['file_path']['image_import_default_upload_path'] = array(
    '#type' => 'textfield',
    '#title' => t('Default import path'),
    '#description' => t('<p>This should be set to the default import path (see above), but as viewed by a typical user during an FTP or similar upload. This may be either an absolute path or a path relative to the user\'s system home directory.<p>If you specify this setting, the interactive help for this module will use it in the text explaining how to upload files, customizing the help text as needed for each individual. The setting is not used for anything except generating help text.'),
    '#default_value' => variable_get('image_import_default_upload_path',''),
    '#maxlength' => 50,
    '#size' => 30,
  );
  $form['file_path']['image_import_system_nou'] = array(
    '#type' => 'checkbox',
    '#title' => t('Ignore %u and %U for system user'),
    '#description' => t('<p>If checked, the special administrative user (the first account created when the site was set up) will not be affected by <code>%u</code> or <code>%U</code> in the import path setting. Note that the system user can <i>always</i> override the path if they wish, because that special account has all available privileges.'),
    '#return_value' => '1',
    '#default_value' => variable_get('image_import_system_nou', '0'),
  );
  $form['image_import_force_delete'] = array(
    '#type' => 'checkbox',
    '#title' => t('Force deletion of upload files'),
    '#description' => t('<p>If checked, this option forces image_import to delete any files from the upload directory that have been successfully imported. This is strongly recommended, because if they are not deleted, the next import from the same server directory may re-import these files and create duplicate image nodes. If this option is disabled, users will be offered a choice of whether to keep or delete the files.'),
    '#return_value' => '1',
    '#default_value' => variable_get('image_import_force_delete', '1'),
  );
  $form['advanced'] = array(
    '#type' => 'fieldset',
    '#title' => t('Advanced settings'),
    '#description' => t('These settings can normally be left at the default values'),
    '#tree' => FALSE,
    '#collapsible' => TRUE,
    '#collapsed' => TRUE,
  );
  $form['advanced']['image_import_debug'] = array(
    '#type' => 'checkbox',
    '#title' => t('Debug Mode'),
    '#description' => t('<p>Turn this option on to enable verbose error checking and detailed messages. May be confusing to novice users, but extremely useful if you are having problems with importing images.'),
    '#return_value' => '1',
    '#default_value' => variable_get('image_import_debug', '0'),
  );
  $form['advanced']['image_import_adjust_order'] = array(
    '#type' => 'checkbox',
    '#title' => t('Adjust timestamp order of images'),
    '#description' => t('By default, imported images are marked as created at the actual time they are imported. Since images are imported in filename order, this may cause some albums or galleries to appear in reverse order. Checking this option causes the import to apply a reversed-order timestamp to correct this, though that means the displayed creation timewill differ by a few seconds from the actual creation time. This setting establishes a default for this option, but users can override that default for each import, if they prefer.'),
    '#return_value' => '1',
    '#default_value' => variable_get('image_import_adjust_order', '0'),
  );
  $form['advanced']['image_import_timeout'] = array(
    '#type' => 'select',
    '#title' => t('Time limit per run (seconds)'),
    '#description' => t('If you are having problems with the import script timing out on large directories, and you are not able to modify the web server or PHP parameters to fix the problem, you can enable this option to set a limit on how long image import will process images during a single run. If the time limit is reached, the user can simply re-run the same job again to do the next group of images, repeating until the entire directory has been imported. <strong>This option is ignored unless you and/or the user enable deletion of images after import, because otherwise you would import the same files over and over.</strong> It is recommended to set this option to slightly <em>less than</em> the PHP <code>max_execution_time</code> limit. On this site, <code>max_execution_time</code>=%met seconds currently. The PHP <code>max_execution_time</code> setting is usually changed in php.ini or httpd.conf (server-wide) or (if allowed) the .htaccess file for this site.', array('%met'=>ini_get('max_execution_time'))),
    '#options' => drupal_map_assoc(array(15, 20, 30, 45, 60, 90, 120, 180, 240, 300)),
    '#default_value' => variable_get('image_import_timeout', '0'),
  );
  $form['text1'] = array(
    '#type' => 'fieldset',
    '#title' => t('Security settings'),
    '#description' => t('<p>You will need to define appropriate %roles that have %permission to upload files, then establish an appropriate list of permitted %extensions for each of these roles.', array('%roles'=>l(t('security roles'),'admin/access/roles'), '%permission'=>l(t('permission'),'admin/access'), '%extensions'=>l(t('file extensions'),'admin/settings/upload'))),
    '#collapsible' => TRUE,
    '#collapsed' => FALSE,
  );

  return $form;
}

/**
 * Checks the path settings and reports any problems detected.
 * $with_post (default TRUE) is passed to image_import_get_import_path()
 * (q.v.). $path_fieldname indicates the fieldname with which any path
 * error should be associated (the outer subscript 'edit' is implied and
 * should not be included in the fieldname). The fieldname defaults to none.
 */
function _image_import_check_settings($with_post=TRUE, $path_fieldname='') {
  $filepath = variable_get('file_directory_path','');
  if (empty($filepath)) {
    drupal_set_message(t('Upload module has not yet been configured.'),'error');
    return FALSE;
  }
  $pathsetting = variable_get('image_import_default_import_path','');
  if (empty($pathsetting)) {
    drupal_set_message(t('Image import module has not yet been configured.'),'error');
    return FALSE;
  }
  $image_path = _image_import_get_image_path();
  if ($pathsetting == $image_path) {
    drupal_set_message(t('Image import path may not be the same as the image path.'),'error');
    return FALSE;
  }
  if (! user_access('upload files')) {
    drupal_set_message(t('You do not have permission to upload files, which is a prerequisite for image import.'),'error');
    return FALSE;
  }
  $extensions = _image_import_img_extensions();
  if (count($extensions) < 1) {
    drupal_set_message(t('Your user account has not been configured to allow any upload extensions. The site administrator will need to fix this for you in the settings for the "upload" module.'),'error');
    return FALSE;
  }
  $path = image_import_get_import_path($with_post);
  if (! module_exist('image')) {
    drupal_set_message(t('Image module, a prerequisite for image import, is not installed or is disabled.'),'error');
    return FALSE;
  }
  if (! is_writable($path)) {
    drupal_set_message(t('The image import directory, %p, is missing or is not writable by the web server.', array('%p'=>$path)),'error');
    if (user_access('override image import path')) {
      drupal_set_message(t('Directory must be changed before import will work.'),'warning');
    } else {
      return FALSE;
    }
  }
  $ok = file_check_directory($path, FALSE, $path_fieldname);
  return $ok;
}

/**
 * Scans a multi-level array with term ID numbers buried inside arrays
 * inside arrays inside arrays...etc., and returns a simple array with just
 * the tid numbers linearized plus, optionally, any free-tags entered by the
 * user if a free-tag string is present in the input array.
 *
 * WARNING: This function uses recursion; modify with care or an infinite
 * recursion loop is possible.
 *
 * For the outermost (non-recursed) invocation only, the parameter $keep_tags
 * (default TRUE) tells the function to retain, unmodified, any element of
 * the $tid_array whose subscript is 'tags'. This causes the subarray placed
 * by the free-tag patch to taxonomy.module to work correctly across previews.
 * Note that $tid_array['tags'] is a sub-array containing one or more string
 * element(s), indexed by vocabulary ID (vid), with the free-form tags.
 *
 * If your installation does not have the free-tag support, the $keep_tags
 * parameter has no effect since $tid_array['tags'] will not be present.
 * It is necessary to disable $keep_tags only if you want to ensure that the
 * returned array from this function has only existing tids in it.
 */
function _image_import_extract_tids($tid_array, $keep_tags=TRUE) {
  $tids = array();
  if (is_array($tid_array)) {
    foreach ($tid_array as $key=>$element) {
      if (is_int($key)) {
        if (is_array($element)) {
          // $keep_tags is NEVER useful when recursing
          $tids = array_merge($tids, _image_import_extract_tids($element, FALSE));
        } else {
          // Toss out zero values
          if (intval($element)) {
            $tids[] = $element;
          }
        }
      }
    }
  }
  if ($keep_tags && isset($tid_array['tags'])) {
    $tids['tags'] = $tid_array['tags'];
  }
  return $tids;
}

/**
 * This internal function looks up a variable containing a default path for
 * something (optionally defaulting to the value in the second parameter)
 * and then applies this module's path mangling rules for replaceable
 * parameters and other features, plus some syntax cleanup.
 */
function _image_import_get_path($variable_name, $variable_default_value='') {
  global $user;
  $uname = $user->name;
  // If this is the system user, and settings instruct ignoring %u and %U for that
  // user, then force $uname to be empty.
  if ($user->uid == 1 && variable_get('image_import_system_nou',FALSE)) {
    $uname = '';
  }
  // Remove space, %, <, >, *, /, \, and ? from the username for %U
  $uname_mod = preg_replace('#[%<>*\\\\ \/?]#','',$uname,-1);
  $pathsetting = variable_get($variable_name, $variable_default_value);
  $path = trim(preg_replace('/%u/',$uname,$pathsetting,-1));
  $path = trim(preg_replace('/%U/',$uname_mod,$pathsetting,-1));
  if (! preg_match('#/$#', $path)) {
    $path .= '/';
  }
  // Remove any double-slashes
  $path = preg_replace('#//#','/',$path,-1);
  return $path;
}

/**
 * Returns the current import path for this user (may be the same as the system
 * default, if "%u"/"%U" wasn't used in the system path setting). The returned path
 * will always have a trailing slash.
 *
 * If $with_post is TRUE (default FALSE), then the value of $_POST['edit']['import_path']
 * will override the other sources of settings *if* the user has the correct permissions.
 */
function image_import_get_import_path($with_post = FALSE) {
  if (user_access('override image import path') && ! empty($_POST['edit']['import_path'])) {
    $path = trim($_POST['edit']['import_path']);
    if (! preg_match('#/$#', $path)) {
      $path .= '/';
    }
    // Remove any double-slashes
    $path = preg_replace('#//#','/',$path,-1);
    return $path;
  }
  return _image_import_get_path('image_import_default_import_path','image_import/%u');
}

/**
 * For the purpose of user-specific help text, this function returns this user's
 * version of the default upload path. The default, if the config variable is
 * missing or empty, is to return image_import_get_import_path().
 *
 * WARNING: Callers should NOT rely on this being any particular format, because
 * it is strictly intended to create strings for help messages. The site admin
 * is allowed to munge the syntax of the setting any way they wish to make it
 * clear to their user community.
 */
function image_import_get_upload_path() {
  return _image_import_get_path('image_import_default_upload_path',
    image_import_get_import_path());
}

/**
 * Implementation of hook_menu
 */
function image_import_menu($may_cache) {
  global $user;
  $items = array();
  if ($may_cache) {
    $items[] = array('path' => 'node/add/image_import', 'title' => t('import images'),
      'callback' => '_image_import_add',
      'access' => user_access('import images'));
//    $items[] = array('path' => 'admin/settings/image_import/legacy', 'title' => t('import from legacy image.module'),
//      'callback' => 'image_import_legacy',
//      'access' => ($user->uid == 1));
  }
  return $items;
}

/**
 * Menu handler for the import functions
 */
function _image_import_add() {
  $html = '';
  // Don't disable the processing of the form if we've already been there,
  // because any "settings failure" will be due to settings in the form
  // itself and not at the system level.
  if (arg(3) == 'help') {
    // Leave HTML alone and let image_import_help() handle it
  } else if (_image_import_check_settings(TRUE, 'import_path') || is_array($_POST['edit'])) {
    $html .= _image_import_form();
  } else {
    $html .= '<p>' . t('Image import is disabled until the %config problem is corrected.', array('%config'=>l('configuration', 'admin/settings/image_import')));
  }
  print(theme('page',"<p>".$html));
}

/**
 * Helper function returns a form for initiating the upload
 */
function _image_import_form() {
  global $user;

  if (is_array($_POST['edit'])) {
    // Assume precheck if the button to actually do it was *not* pressed
    $precheck = $_POST['op']!='Import images'?1:0;    
    $status = image_import_import($precheck);
    // Some options set from POST or from system-wide defaults
    $delete_after = $_POST['edit']['delete_after'];
    $adjust_order = $_POST['edit']['adjust_order'];
  } else {
    // Some options set from POST or from system-wide defaults
    $delete_after = variable_get('image_import_force_delete',FALSE);
    $adjust_order = variable_get('image_import_adjust_order', 0);
  }
  $dummy_node =& new stdClass();
  $dummy_node->type = IMAGE_IMPORT_IMAGE_NODETYPE;
//  $dummy_node->taxonomy =& _image_import_extract_tids($_POST['edit']['taxonomy']);
  $dummy_node->taxonomy = $_POST['edit']['taxonomy'];

  $html = '<p>' . t('An explanation of how to import images is available on the %helplink page.',array('%helplink'=>l(t('detailed instructions'),'node/add/image_import/help')));

  $form = array();
  /*if ($taxonomy_form = taxonomy_node_form($dummy_node)) {
    $form += $taxonomy_form;
  }*/

  $form['advanced'] = array(
    '#type' => 'fieldset',
    '#title' => t('Advanced settings'),
    '#description' => t('These settings can normally be left at the default values'),
    '#tree' => FALSE,
    '#collapsible' => TRUE,
    '#collapsed' => TRUE,
  );
  $form['advanced']['title_pattern'] = array(
    '#type' => 'textfield',
    '#title' => t('Title pattern'),
    '#default_value' => $_POST['edit']['title_pattern'],
    '#maxlength' => 50,
    '#size' => 30,
    '#description' => t('If you leave this blank, each imported file\'s title will be set to match the filename. If you wish, you can specify an alternative title pattern here that will be used as a prefix (e.g., a title pattern of &quot;my title:&quot; will label a file called &quot;photo-0032.jpg&quot; as &quot;my title: photo-0032.jpg&quot;; the import software adds a space if needed between the prefix and the filename). You can embed the label %f within the pattern to specify exactly where you want the filename to go; if you do that, be sure to add your own space(s) where you want them, because the software will create the titles exactly as you specify. And you can embed %c within the pattern; this will be replaced with the first line of the caption file (if found), allowing you to title the image based on its caption file. If this substitution is made, the first line is removed from the caption file after it is extracted for the title.'),
  );
  if (user_access('override image import path')) {
    $form['advanced']['import_path'] = array(
      '#type' => 'textfield',
      '#title' => t('Import path'),
      '#default_value' => image_import_get_import_path(FALSE),
      '#maxlength' => 50,
      '#size' => 30,
      '#description' => t('You can optionally override the directory from which image files will be imported. This is relative to the site\'s top-level directory. The default value is "%path".', array('%path'=>image_import_get_import_path(FALSE))),
    );
  }
  $form['advanced']['adjust_order'] = array(
    '#type' => 'checkbox',
    '#title' => t('Adjust timestamp order of images'),
    '#default_value' => $adjust_order,
    '#return_value'  => 1,
    '#description' => t('By default, imported images are marked as created at the actual time they are imported. Since images are imported in filename order, this may cause some albums or galleries to appear in reverse order. Checking this option causes the import to apply a reversed-order timestamp to correct this, though that means the displayed creation timewill differ by a few seconds from the actual creation time.'),
  );
  if ($user->uid == 1 || ! variable_get('image_import_force_delete',FALSE)) {
    $form['delete_after'] = array(
      '#type' => 'checkbox',
      '#title' => t('Delete uploaded image files after import'),
      '#default_value' => $delete_after,
      '#return_value' => 1,
      '#description' => t('This option causes the import program to delete the images and any caption files from the import directory after they are imported into the gallery.'),
    );
  }
  $form['submit_preview'] = array(
    '#type' => 'submit',
    '#value' => t('Preview import'),
  );
  $form['submit_import'] = array(
    '#type' => 'submit',
    '#value' => t('Import images'),
  );
  
  /* added the following to trick taxonomy_form_alter into adding the categories form element */
  $node = new stdclass();
  $node->type = 'image'; 
  $form['#node'] = $node;
  $form['type'] = array('#value' => 'image');
  /* end of trick */

  // changed the form_id to contain the fragment _node_form; also needed to trick taxonomy_form_alter
  $html .= drupal_get_form('image_node_form', $form);
  return $html;
}

/**
 * From a list of all extensions this module recognizes as image files, returns
 * an array containing only those permitted by system settings for the upload
 * module.
 */
function _image_import_img_extensions() {
  return _image_import_check_ext(array('gif','jpg','jpeg','png','tif','tiff'));
}

/**
 * From a list of all extensions this module recognizes as caption files, returns
 * an array containing only those permitted by system settings for the upload
 * module.
 */
function _image_import_cap_extensions() {
  return _image_import_check_ext(array('html','htm','txt','caption'));
}

/**
 * Given an array of extensions allowed by this module specifically, intersects
 * these with the system-defined list of permitted upload extensions in order
 * to create a subset of only the ones legal in both contexts. The parameter is
 * a simple array whose values are significant but whose keys are not. The return
 * is a simple integer-subscripted array.
 *
 * The lists of extensions for different security roles are stored in variables
 * whose names are "upload_extensions_${rid}". This function merges all of the
 * extensions for the user's roles, then intersects the $ext_array with the
 * result of that merge.
 */
function _image_import_check_ext($ext_array) {
  global $user;
  // Special handling for the superuser
  if ($user->uid == 1) {
    return $ext_array;
  }
  $extensions = array();
  foreach($user->roles as $rid=>$role) {
    $rid = intval($rid);
    $role_extensions = explode(' ',variable_get('upload_extensions_'.$rid, ''));
    $extensions = array_merge($extensions, $role_extensions);
  }
  $extensions = array_values(array_intersect($ext_array, $extensions));
  return $extensions;
}

/**
 * Calculates the largest upload size for the current user, by finding the
 * maximum of variables named "upload_uploadsize_${rid}" and the system
 * upload limit.
 */
function _image_import_max_upload_size() {
  global $user;
  $size = 0;
  foreach($user->roles as $rid=>$role) {
    $rid = intval($rid);
    $role_size = intval(variable_get('upload_uploadsize_'.$rid, 0));
    $size = max($size, $role_size);
  }
  $size = min(intval(variable_get('upload_maxsize_total',99999999)), $size);
  return $size;
}

/**
 * Processes, or pre-checks, the import of the file(s) in the import directory.
 * Returns an associative array (keyed by basename) of the images that would
 * be imported (precheck mode) or for which import was attempted.
 *
 * Returns one of the status code constants.
 */
function image_import_import($precheck_only=TRUE) {
  global $user;
  $debug = variable_get('image_import_debug', 0);
  if ($debug) drupal_set_message(t('DEBUG MODE ENABLED for image_import_import() function. There will be extra messages issued.'),'debug');

  $start = time();
  $timeout = intval(variable_get('image_import_timeout', 0));
  $adjust_order = $_POST['edit']['adjust_order'];
  if ($debug && $adjust_order) drupal_set_message(t('DEBUG: Throttle is enabled.'),'debug');
  $is_personal = ($_POST['edit']['personal'] || ! user_access('import system images'));
  $extensions  = _image_import_img_extensions();
  $cap_extensions = _image_import_cap_extensions();
  if ($is_personal) {
    drupal_set_message(t('Personal albums not yet supported; importing to system galleries.'),'warning');
  }
  if ($user->uid == 1 || ! variable_get('image_import_force_delete',FALSE)) {
    $do_delete = $_POST['edit']['delete_after'];
  } else {
    $do_delete = variable_get('image_import_force_delete',FALSE);
  }
  if (! $do_delete && $timeout > 0) {
    drupal_set_message(t('Normal %time second time limit will be ignored because files are not being deleted after import.', array('%time'=>$timeout)), 'warning');
    $timeout = 0;
  }
  $title_pattern = $_POST['edit']['title_pattern'];
  // If the user specified an exact pattern, take it on faith that they know what they're doing.
  // Otherwise, make sure it ends with a blank and then append %f so that the actual import
  // has a place to put the filename.
  if (! preg_match('/%[fc]/',$title_pattern)) {
    $title_pattern .= ' %f';
    $title_pattern = preg_replace('/  /',' ',$title_pattern,-1);
  }
  // No matter what, no leading or trailing blanks
  $title_pattern = trim($title_pattern);
  if (is_array($extensions)) {
    $img_ext = array();
    foreach ($extensions as $extension) {
      $lc = strtolower($extension);
      $uc = strtoupper($extension);
      $img_ext[] = $lc;
      $img_ext[] = $uc;
    }
    if ($debug) drupal_set_message(t('DEBUG: Image file extensions: %ext',array('%ext'=>implode(',',$img_ext))),'debug');
  } else {
    drupal_set_message(t('Internal error: invalid file extension list in image_import_import()'),'error');
    return IMAGE_IMPORT_STATUS_ABORT;
  }
  $path = image_import_get_import_path(TRUE);
  $img_mask = '\.(' . implode('|',$img_ext) . ')$';
  $files = file_scan_directory($path, $img_mask, array('.', '..', 'CVS'), 0, FALSE, 'name');
  if (! count($files)) {
    drupal_set_message(t('No image files were found in the import directory %p.',array('%p'=>$path)), 'warning');
  } else {
    // The directory scan doesn't necessarily return the files in a reasonable order
    ksort($files);
    $found_count = 0;
    $captioned_count = 0;
    $imported_count  = 0;
    $error_count     = 0;
    if (is_array($cap_extensions)) {
      $cap_ext = array();
      foreach ($cap_extensions as $extension) {
        $lc = strtolower($extension);
        $uc = strtoupper($extension);
        $cap_ext[] = $lc;
        $cap_ext[] = $uc;
      }
      if ($debug) drupal_set_message(t('DEBUG: Caption file extensions: %ext',array('%ext'=>implode(',',$cap_ext))),'debug');
    } else {
      drupal_set_message(t('Internal error: invalid caption extension list in image_import_import()'),'error');
      return IMAGE_IMPORT_STATUS_ABORT;
    }
    $terms =& _image_import_extract_tids($_POST['edit']['taxonomy']);

    if (! is_array($terms) || count($terms) < 1) {
      drupal_set_message(t('No categories selected for images; aborting.'),'error');
      return IMAGE_IMPORT_STATUS_ABORT;
    }
    $last = time() + count($files);
    $nfile = 0;
    foreach($files as $file) {
      $nfile++;
      // Do the files in reverse time order so they'll sort sensibly
      $now = $last - $nfile;
      if ($debug) drupal_set_message(t("DEBUG: Timestamp for file number %n is %t", array('%n'=>$nfile, '%t'=>$now)), 'debug');
      $elapsed = time() - $start;
      if ($timeout > 0 && $elapsed >= $timeout) {
        drupal_set_message(t('Time limit expired. One or more images remain to be imported. Repeat the import to continue processing these images.'),'warning');
        return IMAGE_IMPORT_STATUS_OK_TIMEOUT;
      }
      $found_count++;
      // Import or check ONE file only
      $rc = image_import_import_one($file, $cap_ext, $precheck_only, $title_pattern, $do_delete, $terms, ($adjust_order ? $now : 0));
      switch ($rc) {
        case IMAGE_IMPORT_STATUS_OK_CAPTION:
          $captioned_count++;
          // Intentional fall-through here.
        case IMAGE_IMPORT_STATUS_OK:
          $imported_count++;
          if ($do_delete && ! $precheck_only) $deleted_count++;
          break;
        case IMAGE_IMPORT_STATUS_ABORT:
          drupal_set_message(t('Fatal error. Import processing aborted.'), 'error');
          break 2;
        case IMAGE_IMPORT_STATUS_ERROR:
          $error_count++;
          break;
        default:
          if ($rc < 0) {
            $error_count++;
          } else {
            $imported_count++;
            if ($do_delete && ! $precheck_only) $deleted_count++;
          }
      }
    }
    if ($precheck_only) {
      drupal_set_message(t('Found %n file(s) to import, with %c captioned from files.',array('%n'=>$found_count,'%c'=>$captioned_count)));
    } else {
      drupal_set_message(t('Successfully imported %i file(s) out of %n, with %c captioned from files.', array('%i'=>$imported_count, '%n'=>$found_count, '%c'=>$captioned_count)));
      watchdog('image import',t('Successfully imported %i file(s) out of %n, with %c captioned from files.', array('%i'=>$imported_count, '%n'=>$found_count, '%c'=>$captioned_count)), WATCHDOG_NOTICE);
    }
    if ($deleted_count) {
      drupal_set_message(t('Deleted %d image(s) and associated caption(s) from the import directory.', array('%d'=>$deleted_count)));
    }
  }
  return IMAGE_IMPORT_STATUS_OK;
}

/**
 * Attempt to import, or just to check, one file.
 *
 * Returns one of the following status values:
 * IMAGE_IMPORT_STATUS_ABORT          The attempt was aborted due to an internal
 *                                    error, and a message has been queued to the user.
 * IMAGE_IMPORT_STATUS_OK             The attempt succeeded and the image was imported
 *                                    (or would be expected to import okay).
 * IMAGE_IMPORT_STATUS_OK_CAPTION     The attempt succeeded (or is expected to succeed)
 *                                    and a caption file was found for the image.
 * IMAGE_IMPORT_STATUS_ERROR          The image cannot be imported; a message has been
 *                                    queued to report the specific problem.
 * Other status codes may be added in the future. The application may safely assume
 * that any code >= 0 is some form of success, and any code < 0 is some form of failure.
 */
function image_import_import_one($file, $cap_ext, $precheck_only=TRUE, $title_pattern='%f', $do_delete=FALSE, $terms=NULL, $timestamp=0) {
  global $user;
  $debug = variable_get('image_import_debug', 0);
  if (! is_object($file)) {
    drupal_set_message(t('Import function called with null file; aborting.'),'error');
    return IMAGE_IMPORT_STATUS_ABORT;
  }
  if (! is_array($cap_ext)) {
    drupal_set_message(t('Import function called with empty caption list; aborting.'),'error');
    return IMAGE_IMPORT_STATUS_ABORT;
  }
  if (! is_array($terms) || count($terms) < 1) {
    drupal_set_message(t('No categories selected for images; aborting.'),'error');
    return IMAGE_IMPORT_STATUS_ABORT;
  }
  if (! $timestamp) {
    $timestamp = time();
  }
  $cap_mask = '\.(' . implode('|',$cap_ext) . ')$';
  // Double-slashes in paths don't seem to matter to the o.s., but they
  // confuse the user in error messages, so we get rid of them here.
  $path = preg_replace('#//#','/',$file->filename,-1);
  if ($debug) drupal_set_message(t('DEBUG: Import called for path=%path',array('%path'=>$path)),'debug');
  // Access checks on the file
  if (! is_readable($path)) {
    drupal_set_message(t('The web server cannot read %f -- skipping.', array('%f'=>$path)),'error');
    return IMAGE_IMPORT_STATUS_ERROR;
  }
  if (! is_writable($path)) {
    drupal_set_message(t('Image file %f is not writable by the web server -- skipping.', array('%f'=>$path)),'error');
    return IMAGE_IMPORT_STATUS_ERROR;
  }
  if ($debug) drupal_set_message(t('DEBUG: Access checks succeeded for %path',array('%path'=>$path)),'debug');
  $caption = '';
  $cap_extensions = _image_import_cap_extensions();
  $cap_firstline = '';
  foreach ($cap_extensions as $ext) {
    $caption_path = preg_replace('#\.[^.]+$#','.'.$ext, $path);
    if (file_exists($caption_path)) {
      if ($debug) drupal_set_message(t('DEBUG: Found caption file %file',array('%file'=>$caption_path)),'debug');
      if (! is_readable($caption_path)) {
        drupal_set_message(t('The web server cannot read %f -- skipping.', array('%f'=>$caption_path)),'error');
        return IMAGE_IMPORT_STATUS_ERROR;
      }
      if ($do_delete && ! is_writable($caption_path)) {
        drupal_set_message(t('Delete of imported files is enabled, but caption file %f is not writable by the web server -- skipping image.', array('%f'=>$caption_path)),'error');
        return IMAGE_IMPORT_STATUS_ERROR;
      }
      $caption = file_get_contents($caption_path, FALSE);
      $caption = preg_replace('#\r\n#m',"\n",$caption,-1);
      $caption = preg_replace('#\r#m',"\n",$caption,-1);
      if (strpos($title_pattern, '%c') !== FALSE) {
        $lines = explode("\n", $caption);
        $cap_firstline = trim(strip_tags($lines[0]));
        if (! empty($cap_firstline)) {
          unset($lines[0]);
          $caption = implode("\n", $lines);
        }
      }
      $caption = '<p>' . $caption;
      $caption = preg_replace('#\n\s*\n#m',"\n<p>\n",$caption,-1);
      $caption = preg_replace('#<p>\s*<p>#m','<p>',$caption,-1);
      break;
    }
  }
  $title = trim(preg_replace('#%f#',$file->basename,$title_pattern));
  $title = trim(preg_replace('#%c#',$cap_firstline,$title));
  if ($debug) drupal_set_message(t('DEBUG: Title pattern is "%p".', array('%p'=>$title_pattern)), 'debug');
  if ($debug) drupal_set_message(t('DEBUG: Title is "%t".', array('%t'=>$title)), 'debug');
  $files[$name]->title = $title;
  $teaser  = node_teaser($caption);
  if ($debug) drupal_set_message(t('DEBUG: Caption %c characters, teaser %t characters, for %n.', array('%c'=>strlen($caption), '%t'=>strlen($teaser), '%n'=>$file->basename)),'debug');

  $nodeoptions = variable_get('node_options_image_import','');
  if (! is_array($nodeoptions)) {
    drupal_set_message(t('Node workflow options have not been %configured for the image_import type. Defaults will be used.', array('%configured'=>l(t('configured'),'admin/node/configure/types/image_import'))), 'warning');
    $nodeoptions = array();
  }

  // ****** All prechecks are completed here *******
  if ($precheck_only || $debug) {
    drupal_set_message(($debug ? t('DEBUG: ') : '') . t('Image %n prechecks okay and should import successfully.', array('%n'=>$file->basename)), $debug ? 'debug' : 'status');
  }
  if ($precheck_only) {
    return (empty($caption) ? IMAGE_IMPORT_STATUS_OK : IMAGE_IMPORT_STATUS_OK_CAPTION);
  }

  // ****** The following executes only if we are doing a real import ******

  $node =& new stdClass();
  $node->type = IMAGE_IMPORT_IMAGE_NODETYPE;
  $node->uid  = $user->uid;
  $node->title  = $title;
  $node->body   = $caption;
  $node->teaser = $teaser;
  $node->created = $timestamp;
  $node->changed = $timestamp;
  $node->promote  = in_array('promote', $nodeoptions) ? 1 : 0;
  $node->status   = in_array('status', $nodeoptions) ? 1 : 0;
  $node->sticky   = in_array('sticky', $nodeoptions) ? 1 : 0;
  $node->revision = in_array('revision', $nodeoptions) ? 1 : 0;
  $node->moderate = in_array('moderate', $nodeoptions) ? 1 : 0;
  $node->comment  = variable_get('comment_image_import',0);

  if (! image_import_do_node($node, $path)) {
    return IMAGE_IMPORT_STATUS_ERROR;
  }
  
  $nid = $node->nid;

  taxonomy_node_save($nid, $terms);
  if ($debug) drupal_set_message(t('DEBUG: Saved taxonomy for node nid=%nid',array('%nid'=>$nid)),'debug');
  _image_build_derivatives($node, FALSE);
  if ($debug) drupal_set_message(t('DEBUG: Built derivatives for node nid=%nid',array('%nid'=>$nid)),'debug');

  if ($do_delete) {
    $cap_ok = file_exists($caption_path) ? file_delete($caption_path) : FALSE;
    if ($cap_ok) drupal_set_message(t('Deleted caption file %p',array('%p'=>$caption_path)),'status');
    $img_ok = file_exists($path)   ? file_delete($path) : FALSE; 
    if ($img_ok) drupal_set_message(t('Deleted image file %p',array('%p'=>$path)),'status');
  }

  if (empty($caption)) {
    return IMAGE_IMPORT_STATUS_OK;
  } else {
    return IMAGE_IMPORT_STATUS_OK_CAPTION;
  }
}

/**
 * Perform the bare image import process on a predefined (existing or new)
 * node object. All this function does is to physically the file from its
 * current location into the image directory, then save the node object
 * using the Drupal node API.
 *
 * $path is the Drupal path to the image file in the import directory.
 */
function image_import_do_node(&$node, $path) {
  $debug = variable_get('image_import_debug', 0);

  $image_dir = _image_import_get_image_path();
  if ($debug) drupal_set_message(t('DEBUG: System image directory is \'%id\'.', array('%id'=>$image_dir)), 'debug');

  // Need this dummy array because node_save() calls image_insert() since
  // this is a node of type 'image'. In this situation, however, we will
  // take care of importing the file for this node separately.
  $node->images = array();

  // Copy the image file into the appropriate directory
  $new_path = $path;
  if ($debug) drupal_set_message(t('DEBUG: Invoking file_copy(\'%path\', \'%dir\', FILE_EXISTS_RENAME)', array('%path'=>$new_path,'%dir'=>$image_dir)), 'debug');
  if (file_copy($new_path, $image_dir, FILE_EXISTS_RENAME)) {
    // The $tmp_path receives the destination path
    if ($debug) drupal_set_message(t('DEBUG: Copied %p to %np.', array('%p'=>$path, '%np'=>$new_path)), 'debug');
  } else {
    drupal_set_message(t('File copy failed for %p to %tp', array('%p'=>$path, '%tp'=>$tmp_path)), 'error');
    return FALSE;
  }
  $node->file = $node->images['_original'] = $new_path;

  // saving a node - first step is to validate
  $node = node_submit($node);
  if ($node->validated) {
    // ... then we save the node
    node_save($node);
    if ($debug) drupal_set_message(t('DEBUG: Saved node nid=%nid',array('%nid'=>$nid)),'debug');
    watchdog('image import',t('Imported "%p" as node %nid',array('%p'=>$path, '%nid'=>$nid)), WATCHDOG_NOTICE, l(t('view'),"node/$nid"));
  } else {
    drupal_set_message(t('Unable to create image node.'),'error');
    return FALSE;
  }
  return TRUE;
}

/**
 * Attempt to fully process an input image file, creating all resized
 * versions and storing it into the {files} database table.
 */
function &_image_import_get_file_object($filepath) {
  $info = image_get_info($filepath);
  $file = new StdClass(); 
  $file->filename = trim(basename($filepath), '.'); 
  $file->filemime = $info['mime_type'];
  $file->filepath = $filepath;
  $file->error = '';
  $file->filesize = filesize($filepath);
  return $file;
}

/**
 * Looks up the current default path for images, from the image.module and
 * uploads.module settings.
 */
function _image_import_get_image_path() {
  $imgpath  = variable_get('image_default_path','');
  $filepath = variable_get('file_directory_path','');
  $path = $filepath . '/' . $imgpath;
  $path = preg_replace('#//#','',$path,-1);
  // file_downloads value is 1 for public, 2 for private
  $dl_type = variable_get('file_downloads','');
  if ($dl_type<>2) {
    $path = preg_replace('#^/#','',$path);
  }
  $path = preg_replace('#/$#','',$path);
  return $path;
}
?>