<?php

/**

 * @file

 * Field module functionality for the File module.

 */

/**

 * Implements hook_field_info().

 */

function file_field_info() {

  return array(

    'file' => array(

      'label' => t('File'),

      'description' => t('This field stores the ID of a file as an integer value.'),

      'settings' => array(

        'display_field' => 0,

        'display_default' => 0,

        'uri_scheme' => variable_get('file_default_scheme', 'public'),

      ),

      'instance_settings' => array(

        'file_extensions' => 'txt',

        'file_directory' => '',

        'max_filesize' => '',

        'description_field' => 0,

      ),

      'default_widget' => 'file_generic',

      'default_formatter' => 'file_default',

    ),

  );

}

/**

 * Implements hook_field_settings_form().

 */

function file_field_settings_form($field, $instance, $has_data) {

  $defaults = field_info_field_settings($field['type']);

  $settings = array_merge($defaults, $field['settings']);

  $form['#attached']['js'][] = drupal_get_path('module', 'file') . '/file.js';

  $form['display_field'] = array(

    '#type' => 'checkbox',

    '#title' => t('Enable <em>Display</em> field'),

    '#default_value' => $settings['display_field'],

    '#description' => t('The display option allows users to choose if a file should be shown when viewing the content.'),

  );

  $form['display_default'] = array(

    '#type' => 'checkbox',

    '#title' => t('Files displayed by default'),

    '#default_value' => $settings['display_default'],

    '#description' => t('This setting only has an effect if the display option is enabled.'),

  );

  $scheme_options = array();

  foreach (file_get_stream_wrappers(STREAM_WRAPPERS_WRITE_VISIBLE) as $scheme => $stream_wrapper) {

    $scheme_options[$scheme] = $stream_wrapper['name'];

  }

  $form['uri_scheme'] = array(

    '#type' => 'radios',

    '#title' => t('Upload destination'),

    '#options' => $scheme_options,

    '#default_value' => $settings['uri_scheme'],

    '#description' => t('Select where the final files should be stored. Private file storage has significantly more overhead than public files, but allows restricted access to files within this field.'),

    '#disabled' => $has_data,

  );

  return $form;

}

/**

 * Implements hook_field_instance_settings_form().

 */

function file_field_instance_settings_form($field, $instance) {

  $settings = $instance['settings'];

  $form['file_directory'] = array(

    '#type' => 'textfield',

    '#title' => t('File directory'),

    '#default_value' => $settings['file_directory'],

    '#description' => t('Optional subdirectory within the upload destination where files will be stored. Do not include preceding or trailing slashes.'),

    '#element_validate' => array('_file_generic_settings_file_directory_validate'),

    '#weight' => 3,

  );

  // Make the extension list a little more human-friendly by comma-separation.

  $extensions = str_replace(' ', ', ', $settings['file_extensions']);

  $form['file_extensions'] = array(

    '#type' => 'textfield',

    '#title' => t('Allowed file extensions'),

    '#default_value' => $extensions,

    '#description' => t('Separate extensions with a space or comma and do not include the leading dot.'),

    '#element_validate' => array('_file_generic_settings_extensions'),

    '#weight' => 1,

    '#maxlength' => 256,

    // By making this field required, we prevent a potential security issue

    // that would allow files of any type to be uploaded.

    '#required' => TRUE,

  );

  $form['max_filesize'] = array(

    '#type' => 'textfield',

    '#title' => t('Maximum upload size'),

    '#default_value' => $settings['max_filesize'],

    '#description' => t('Enter a value like "512" (bytes), "80 KB" (kilobytes) or "50 MB" (megabytes) in order to restrict the allowed file size. If left empty the file sizes will be limited only by PHP\'s maximum post and file upload sizes (current limit <strong>%limit</strong>).', array('%limit' => format_size(file_upload_max_size()))),

    '#size' => 10,

    '#element_validate' => array('_file_generic_settings_max_filesize'),

    '#weight' => 5,

  );

  $form['description_field'] = array(

    '#type' => 'checkbox',

    '#title' => t('Enable <em>Description</em> field'),

    '#default_value' => isset($settings['description_field']) ? $settings['description_field'] : '',

    '#description' => t('The description field allows users to enter a description about the uploaded file.'),

    '#parents' => array('instance', 'settings', 'description_field'),

    '#weight' => 11,

  );

  return $form;

}

/**

 * Element validate callback for the maximum upload size field.

 *

 * Ensure a size that can be parsed by parse_size() has been entered.

 */

function _file_generic_settings_max_filesize($element, &$form_state) {

  if (!empty($element['#value']) && !is_numeric(parse_size($element['#value']))) {

    form_error($element, t('The "!name" option must contain a valid value. You may either leave the text field empty or enter a string like "512" (bytes), "80 KB" (kilobytes) or "50 MB" (megabytes).', array('!name' => t($element['title']))));

  }

}

/**

 * Element validate callback for the allowed file extensions field.

 *

 * This doubles as a convenience clean-up function and a validation routine.

 * Commas are allowed by the end-user, but ultimately the value will be stored

 * as a space-separated list for compatibility with file_validate_extensions().

 */

function _file_generic_settings_extensions($element, &$form_state) {

  if (!empty($element['#value'])) {

    $extensions = preg_replace('/([, ]+\.?)/', ' ', trim(strtolower($element['#value'])));

    $extensions = array_filter(explode(' ', $extensions));

    $extensions = implode(' ', array_unique($extensions));

    if (!preg_match('/^([a-z0-9]+([.][a-z0-9])* ?)+$/', $extensions)) {

      form_error($element, t('The list of allowed extensions is not valid, be sure to exclude leading dots and to separate extensions with a comma or space.'));

    }

    else {

      form_set_value($element, $extensions, $form_state);

    }

  }

}

/**

 * Element validate callback for the file destination field.

 *

 * Remove slashes from the beginning and end of the destination value and ensure

 * that the file directory path is not included at the beginning of the value.

 */

function _file_generic_settings_file_directory_validate($element, &$form_state) {

  // Strip slashes from the beginning and end of $widget['file_directory'].

  $value = trim($element['#value'], '\\/');

  form_set_value($element, $value, $form_state);

}

/**

 * Implements hook_field_load().

 */

function file_field_load($entity_type, $entities, $field, $instances, $langcode, &$items, $age) {

  $fids = array();

  foreach ($entities as $id => $entity) {

    // Load the files from the files table.

    foreach ($items[$id] as $delta => $item) {

      if (!empty($item['fid'])) {

        $fids[] = $item['fid'];

      }

    }

  }

  $files = file_load_multiple($fids);

  foreach ($entities as $id => $entity) {

    foreach ($items[$id] as $delta => $item) {

      // If the file does not exist, mark the entire item as empty.

      if (empty($item['fid']) || !isset($files[$item['fid']])) {

        $items[$id][$delta] = NULL;

      }

      else {

        $items[$id][$delta] = array_merge((array) $files[$item['fid']], $item);

      }

    }

  }

}

/**

 * Implements hook_field_prepare_view().

 */

function file_field_prepare_view($entity_type, $entities, $field, $instances, $langcode, &$items) {

  // Remove files specified to not be displayed.

  foreach ($entities as $id => $entity) {

    foreach ($items[$id] as $delta => $item) {

      if (!file_field_displayed($item, $field)) {

        unset($items[$id][$delta]);

      }

    }

    // Ensure consecutive deltas.

    $items[$id] = array_values($items[$id]);

  }

}

/**

 * Implements hook_field_presave().

 */

function file_field_presave($entity_type, $entity, $field, $instance, $langcode, &$items) {

  // Make sure that each file which will be saved with this object has a

  // permanent status, so that it will not be removed when temporary files are

  // cleaned up.

  foreach ($items as $delta => $item) {

    if (empty($item['fid'])) {

      unset($items[$delta]);

      continue;

    }

    $file = file_load($item['fid']);

    if (empty($file)) {

      unset($items[$delta]);

      continue;

    }

    if (!$file->status) {

      $file->status = FILE_STATUS_PERMANENT;

      file_save($file);

    }

  }

}

/**

 * Implements hook_field_insert().

 */

function file_field_insert($entity_type, $entity, $field, $instance, $langcode, &$items) {

  list($id, $vid, $bundle) = entity_extract_ids($entity_type, $entity);

  // Add a new usage of each uploaded file.

  foreach ($items as $item) {

    $file = (object) $item;

    file_usage_add($file, 'file', $entity_type, $id);

  }

}

/**

 * Implements hook_field_update().

 *

 * Checks for files that have been removed from the object.

 */

function file_field_update($entity_type, $entity, $field, $instance, $langcode, &$items) {

  // Check whether the field is defined on the object.

  if (!isset($entity->{$field['field_name']})) {

    // We cannot check for removed files if the field is not defined.

    return;

  }

  list($id, $vid, $bundle) = entity_extract_ids($entity_type, $entity);

  // On new revisions, all files are considered to be a new usage and no

  // deletion of previous file usages are necessary.

  if (!empty($entity->revision)) {

    foreach ($items as $item) {

      $file = (object) $item;

      file_usage_add($file, 'file', $entity_type, $id);

    }

    return;

  }

  // Build a display of the current FIDs.

  $current_fids = array();

  foreach ($items as $item) {

    $current_fids[] = $item['fid'];

  }

  // Compare the original field values with the ones that are being saved. Use

  // $entity->original to check this when possible, but if it isn't available,

  // create a bare-bones entity and load its previous values instead.

  if (isset($entity->original)) {

    $original = $entity->original;

  }

  else {

    $original = entity_create_stub_entity($entity_type, array($id, $vid, $bundle));

    field_attach_load($entity_type, array($id => $original), FIELD_LOAD_CURRENT, array('field_id' => $field['id']));

  }

  $original_fids = array();

  if (!empty($original->{$field['field_name']}[$langcode])) {

    foreach ($original->{$field['field_name']}[$langcode] as $original_item) {

      $original_fids[] = $original_item['fid'];

      if (isset($original_item['fid']) && !in_array($original_item['fid'], $current_fids)) {

        // Decrement the file usage count by 1 and delete the file if possible.

        file_field_delete_file($original_item, $field, $entity_type, $id);

      }

    }

  }

  // Add new usage entries for newly added files.

  foreach ($items as $item) {

    if (!in_array($item['fid'], $original_fids)) {

      $file = (object) $item;

      file_usage_add($file, 'file', $entity_type, $id);

    }

  }

}

/**

 * Implements hook_field_delete().

 */

function file_field_delete($entity_type, $entity, $field, $instance, $langcode, &$items) {

  list($id, $vid, $bundle) = entity_extract_ids($entity_type, $entity);

  // Delete all file usages within this entity.

  foreach ($items as $delta => $item) {

    file_field_delete_file($item, $field, $entity_type, $id, 0);

  }

}

/**

 * Implements hook_field_delete_revision().

 */

function file_field_delete_revision($entity_type, $entity, $field, $instance, $langcode, &$items) {

  list($id, $vid, $bundle) = entity_extract_ids($entity_type, $entity);

  foreach ($items as $delta => $item) {

    // Decrement the file usage count by 1 and delete the file if possible.

    if (file_field_delete_file($item, $field, $entity_type, $id)) {

      $items[$delta] = NULL;

    }

  }

}

/**

 * Decrements the usage count for a file and attempts to delete it.

 *

 * This function only has an effect if the file being deleted is used only by

 * File module.

 *

 * @param $item

 *   The field item that contains a file array.

 * @param $field

 *   The field structure for the operation.

 * @param $entity_type

 *   The type of $entity.

 * @param $id

 *   The entity ID which contains the file being deleted.

 * @param $count

 *   (optional) The number of references to decrement from the object

 *   containing the file. Defaults to 1.

 *

 * @return

 *   Boolean TRUE if the file was deleted, or an array of remaining references

 *   if the file is still in use by other modules. Boolean FALSE if an error

 *   was encountered.

 */

function file_field_delete_file($item, $field, $entity_type, $id, $count = 1) {

  // To prevent the file field from deleting files it doesn't know about, check

  // the file reference count. Temporary files can be deleted because they

  // are not yet associated with any content at all.

  $file = (object) $item;

  $file_usage = file_usage_list($file);

  if ($file->status == 0 || !empty($file_usage['file'])) {

    file_usage_delete($file, 'file', $entity_type, $id, $count);

    return file_delete($file);

  }

  // Even if the file is not deleted, return TRUE to indicate the file field

  // record can be removed from the field database tables.

  return TRUE;

}

/**

 * Implements hook_field_is_empty().

 */

function file_field_is_empty($item, $field) {

  return empty($item['fid']);

}

/**

 * Determines whether a file should be displayed when outputting field content.

 *

 * @param $item

 *   A field item array.

 * @param $field

 *   A field array.

 *

 * @return

 *   Boolean TRUE if the file will be displayed, FALSE if the file is hidden.

 */

function file_field_displayed($item, $field) {

  if (!empty($field['settings']['display_field'])) {

    return (bool) $item['display'];

  }

  return TRUE;

}

/**

 * Implements hook_field_formatter_info().

 */

function file_field_formatter_info() {

  return array(

    'file_default' => array(

      'label' => t('Generic file'),

      'field types' => array('file'),

    ),

    'file_table' => array(

      'label' => t('Table of files'),

      'field types' => array('file'),

    ),

    'file_url_plain' => array(

      'label' => t('URL to file'),

      'field types' => array('file'),

    ),

  );

}