filefield.module in FileField 6.3
Same filename and directory in other branches
FileField: Defines a CCK file field type.
Uses content.module to store the fid and field specific metadata, and Drupal's {files} table to store the actual file data.
File
filefield.moduleView source
<?php
/**
* @file
* FileField: Defines a CCK file field type.
*
* Uses content.module to store the fid and field specific metadata,
* and Drupal's {files} table to store the actual file data.
*/
// FileField API hooks should always be available.
require_once dirname(__FILE__) . '/field_file.inc';
require_once dirname(__FILE__) . '/filefield_widget.inc';
/**
* Implementation of hook_init().
*/
function filefield_init() {
// File hooks and callbacks may be used by any module.
drupal_add_css(drupal_get_path('module', 'filefield') . '/filefield.css');
// Conditional module support.
if (module_exists('token')) {
module_load_include('inc', 'filefield', 'filefield.token');
}
}
/**
* Implementation of hook_menu().
*/
function filefield_menu() {
$items = array();
$items['filefield/ahah/%/%/%'] = array(
'page callback' => 'filefield_js',
'page arguments' => array(
2,
3,
4,
),
'access callback' => 'filefield_edit_access',
'access arguments' => array(
2,
3,
),
'type' => MENU_CALLBACK,
);
$items['filefield/progress'] = array(
'page callback' => 'filefield_progress',
'access arguments' => array(
'access content',
),
'type' => MENU_CALLBACK,
);
return $items;
}
/**
* Implementation of hook_elements().
*/
function filefield_elements() {
$elements = array();
$elements['filefield_widget'] = array(
'#input' => TRUE,
'#columns' => array(
'fid',
'list',
'data',
),
'#process' => array(
'filefield_widget_process',
),
'#after_build' => array(
'filefield_widget_after_build',
),
'#value_callback' => 'filefield_widget_value',
'#element_validate' => array(
'filefield_widget_validate',
),
);
return $elements;
}
/**
* Implementation of hook_theme().
* @todo: autogenerate theme registry entrys for widgets.
*/
function filefield_theme() {
return array(
'filefield_file' => array(
'arguments' => array(
'file' => NULL,
),
'file' => 'filefield_formatter.inc',
),
'filefield_icon' => array(
'arguments' => array(
'file' => NULL,
),
'file' => 'filefield.theme.inc',
),
'filefield_widget' => array(
'arguments' => array(
'element' => NULL,
),
'file' => 'filefield_widget.inc',
),
'filefield_widget_item' => array(
'arguments' => array(
'element' => NULL,
),
'file' => 'filefield_widget.inc',
),
'filefield_widget_preview' => array(
'arguments' => array(
'element' => NULL,
),
'file' => 'filefield_widget.inc',
),
'filefield_widget_file' => array(
'arguments' => array(
'element' => NULL,
),
'file' => 'filefield_widget.inc',
),
'filefield_formatter_default' => array(
'arguments' => array(
'element' => NULL,
),
'file' => 'filefield_formatter.inc',
),
'filefield_formatter_url_plain' => array(
'arguments' => array(
'element' => NULL,
),
'file' => 'filefield_formatter.inc',
),
'filefield_formatter_path_plain' => array(
'arguments' => array(
'element' => NULL,
),
'file' => 'filefield_formatter.inc',
),
'filefield_item' => array(
'arguments' => array(
'file' => NULL,
'field' => NULL,
),
'file' => 'filefield_formatter.inc',
),
);
}
/**
* Implementation of hook_file_download().
*/
function filefield_file_download($filepath) {
$filepath = file_create_path($filepath);
$result = db_query("SELECT * FROM {files} WHERE filepath = '%s'", $filepath);
// Ensure case-sensitivity of uploaded file names.
while ($file = db_fetch_object($result)) {
if (strcmp($file->filepath, $filepath) == 0) {
break;
}
}
// If the file is not found in the database, we're not responsible for it.
if (empty($file)) {
return;
}
// See if this is a file on a newly created node, on which the user who
// uploaded it will immediately have access.
$new_node_file = $file->status == 0 && isset($_SESSION['filefield_access']) && in_array($file->fid, $_SESSION['filefield_access']);
if ($new_node_file) {
$denied = FALSE;
}
else {
// Find out if any file field contains this file, and if so, which field
// and node it belongs to. Required for later access checking.
$cck_files = array();
foreach (content_fields() as $field) {
if ($field['type'] == 'filefield' || $field['type'] == 'image') {
$db_info = content_database_info($field);
$table = $db_info['table'];
$fid_column = $db_info['columns']['fid']['column'];
$columns = array(
'vid',
'nid',
);
foreach ($db_info['columns'] as $property_name => $column_info) {
$columns[] = $column_info['column'] . ' AS ' . $property_name;
}
$result = db_query("SELECT " . implode(', ', $columns) . "\n FROM {" . $table . "}\n WHERE " . $fid_column . " = %d", $file->fid);
while ($content = db_fetch_array($result)) {
$content['field'] = $field;
$cck_files[$field['field_name']][$content['vid']] = $content;
}
}
}
// If no file field item is involved with this file, we don't care about it.
if (empty($cck_files)) {
return;
}
// So the overall field view permissions are not denied, but if access is
// denied for ALL nodes containing the file, deny the download as well.
// Node access checks also include checking for 'access content'.
$nodes = array();
$denied = TRUE;
$revision_access = FALSE;
foreach ($cck_files as $field_name => $field_files) {
foreach ($field_files as $revision_id => $content) {
// Checking separately for each revision is probably not the best idea -
// what if 'view revisions' is disabled? So, let's just check for the
// current revision of that node.
if (isset($nodes[$content['nid']])) {
continue;
// Don't check the same node twice.
}
if (($node = node_load($content['nid'])) && (node_access('view', $node) && filefield_view_access($field_name, $node))) {
// They have access to the node.
$denied = FALSE;
}
if (!$denied && $node->vid == $revision_id) {
// If revision is the current revision, grant access.
$revision_access = TRUE;
}
elseif (!$denied) {
$revision_node = node_load($content['nid'], $revision_id);
// You have access to the node as well as that particular revision.
$revision_access = $revision_node && _node_revision_access($revision_node, 'view');
}
// If node access denied, skip other revisions; or if we have node
// access and access to at least one revision the file is present on,
// skip other revision checks.
if ($denied || $revision_access) {
$nodes[$content['nid']] = $node;
break 2;
}
}
}
}
// If they don't have access to the node or file, or if the file is only
// attached to revisions that they don't have access to, deny access.
if ($denied || !$revision_access) {
return -1;
}
// Access is granted.
$name = mime_header_encode($file->filename);
$type = mime_header_encode($file->filemime);
// By default, serve images, text, and flash content for display rather than
// download. Or if variable 'filefield_inline_types' is set, use its patterns.
$inline_types = variable_get('filefield_inline_types', array(
'^text/',
'^image/',
'flash$',
));
$disposition = 'attachment';
foreach ($inline_types as $inline_type) {
// Exclamation marks are used as delimiters to avoid escaping slashes.
if (preg_match('!' . $inline_type . '!', $file->filemime)) {
$disposition = 'inline';
}
}
return array(
'Content-Type: ' . $type . '; name="' . $name . '"',
'Content-Length: ' . $file->filesize,
'Content-Disposition: ' . $disposition . '; filename="' . $name . '"',
'Cache-Control: private',
);
}
/**
* Implementation of hook_views_api().
*/
function filefield_views_api() {
return array(
'api' => 2.0,
'path' => drupal_get_path('module', 'filefield') . '/views',
);
}
/**
* Implementation of hook_form_alter().
*
* Set the enctype on forms that need to accept file uploads.
*/
function filefield_form_alter(&$form, $form_state, $form_id) {
// Field configuration (for default images).
if ($form_id == 'content_field_edit_form' && isset($form['#field']) && $form['#field']['type'] == 'filefield') {
$form['#attributes']['enctype'] = 'multipart/form-data';
}
// Node forms.
if (preg_match('/_node_form$/', $form_id)) {
$form['#attributes']['enctype'] = 'multipart/form-data';
}
}
/**
* Implementation of CCK's hook_field_info().
*/
function filefield_field_info() {
return array(
'filefield' => array(
'label' => t('File'),
'description' => t('Store an arbitrary file.'),
),
);
}
/**
* Implementation of hook_field_settings().
*/
function filefield_field_settings($op, $field) {
$return = array();
module_load_include('inc', 'filefield', 'filefield_field');
$op = str_replace(' ', '_', $op);
$function = 'filefield_field_settings_' . $op;
if (function_exists($function)) {
$result = $function($field);
if (isset($result) && is_array($result)) {
$return = $result;
}
}
return $return;
}
/**
* Implementation of CCK's hook_field().
*/
function filefield_field($op, $node, $field, &$items, $teaser, $page) {
module_load_include('inc', 'filefield', 'filefield_field');
$op = str_replace(' ', '_', $op);
// add filefield specific handlers...
$function = 'filefield_field_' . $op;
if (function_exists($function)) {
return $function($node, $field, $items, $teaser, $page);
}
}
/**
* Implementation of CCK's hook_widget_settings().
*/
function filefield_widget_settings($op, $widget) {
switch ($op) {
case 'form':
return filefield_widget_settings_form($widget);
case 'save':
return filefield_widget_settings_save($widget);
}
}
/**
* Implementation of hook_widget().
*/
function filefield_widget(&$form, &$form_state, $field, $items, $delta = 0) {
// CCK doesn't give a validate callback at the field level...
// and FAPI's #require is naive to complex structures...
// we validate at the field level ourselves.
if (empty($form['#validate']) || !in_array('filefield_node_form_validate', $form['#validate'])) {
$form['#validate'][] = 'filefield_node_form_validate';
}
$form['#attributes']['enctype'] = 'multipart/form-data';
module_load_include('inc', $field['widget']['module'], $field['widget']['module'] . '_widget');
$item = array(
'fid' => 0,
'list' => $field['list_default'],
'data' => array(
'description' => '',
),
);
if (!empty($items[$delta])) {
$item = array_merge($item, $items[$delta]);
}
$element = array(
'#title' => $field['widget']['label'],
'#type' => $field['widget']['type'],
'#default_value' => $item,
'#upload_validators' => filefield_widget_upload_validators($field),
);
return $element;
}
/**
* Get the upload validators for a file field.
*
* @param $field
* A CCK field array.
* @return
* An array suitable for passing to file_save_upload() or the file field
* element's '#upload_validators' property.
*/
function filefield_widget_upload_validators($field) {
$max_filesize = parse_size(file_upload_max_size());
if (!empty($field['widget']['max_filesize_per_file']) && parse_size($field['widget']['max_filesize_per_file']) < $max_filesize) {
$max_filesize = parse_size($field['widget']['max_filesize_per_file']);
}
// Match the default value if no file extensions have been saved at all.
if (!isset($field['widget']['file_extensions'])) {
$field['widget']['file_extensions'] = 'txt';
}
$validators = array(
// associate the field to the file on validation.
'filefield_validate_associate_field' => array(
$field,
),
'filefield_validate_size' => array(
$max_filesize,
),
// Override core since it excludes uid 1 on the extension check.
// Filefield only excuses uid 1 of quota requirements.
'filefield_validate_extensions' => array(
$field['widget']['file_extensions'],
),
);
return $validators;
}
/**
* Implementation of CCK's hook_content_is_empty().
*
* The result of this determines whether content.module will save the value of
* the field. Note that content module has some interesting behaviors for empty
* values. It will always save at least one record for every node revision,
* even if the values are all NULL. If it is a multi-value field with an
* explicit limit, CCK will save that number of empty entries.
*/
function filefield_content_is_empty($item, $field) {
return empty($item['fid']) || (int) $item['fid'] == 0;
}
/**
* Implementation of CCK's hook_content_diff_values().
*/
function filefield_content_diff_values($node, $field, $items) {
$return = array();
foreach ($items as $item) {
if (is_array($item) && !empty($item['filepath'])) {
$return[] = $item['filepath'];
}
}
return $return;
}
/**
* Implementation of CCK's hook_default_value().
*
* Note this is a widget-level hook, so it does not affect ImageField or other
* modules that extend FileField.
*
* @see content_default_value()
*/
function filefield_default_value(&$form, &$form_state, $field, $delta) {
// Reduce the default number of upload fields to one. CCK 2 (but not 3) will
// automatically add one more field than necessary. We use the
// content_multiple_value_after_build function to determine the version.
if (!function_exists('content_multiple_value_after_build') && !isset($form_state['item_count'][$field['field_name']])) {
$form_state['item_count'][$field['field_name']] = 0;
}
// The default value is actually handled in hook_widget().
// hook_default_value() is only helpful for new nodes, and we need to affect
// all widgets, such as when a new field is added via "Add another item".
return array();
}
/**
* Implementation of CCK's hook_widget_info().
*/
function filefield_widget_info() {
return array(
'filefield_widget' => array(
'label' => t('File Upload'),
'field types' => array(
'filefield',
),
'multiple values' => CONTENT_HANDLE_CORE,
'callbacks' => array(
'default value' => CONTENT_CALLBACK_CUSTOM,
),
'description' => t('A plain file upload widget.'),
'file_extensions' => 'txt',
),
);
}
/**
* Implementation of CCK's hook_field_formatter_info().
*/
function filefield_field_formatter_info() {
return array(
'default' => array(
'label' => t('Generic files'),
'field types' => array(
'filefield',
),
'multiple values' => CONTENT_HANDLE_CORE,
'description' => t('Displays all kinds of files with an icon and a linked file description.'),
),
'path_plain' => array(
'label' => t('Path to file'),
'field types' => array(
'filefield',
),
'description' => t('Displays the file system path to the file.'),
),
'url_plain' => array(
'label' => t('URL to file'),
'field types' => array(
'filefield',
),
'description' => t('Displays a full URL to the file.'),
),
);
}
/**
* Implementation of CCK's hook_content_generate(). Used by generate.module.
*/
function filefield_content_generate($node, $field) {
module_load_include('inc', 'filefield', 'filefield.devel');
if (content_handle('widget', 'multiple values', $field) == CONTENT_HANDLE_MODULE) {
return content_devel_multiple('_filefield_content_generate', $node, $field);
}
else {
return _filefield_content_generate($node, $field);
}
}
/**
* Get a list of possible information stored in a file field "data" column.
*/
function filefield_data_info() {
static $columns;
if (!isset($columns)) {
$columns = array();
foreach (module_implements('filefield_data_info') as $module) {
$function = $module . '_filefield_data_info';
$data = (array) $function();
foreach ($data as $key => $value) {
$data[$key] = $value;
$data[$key]['module'] = $module;
}
$columns = array_merge($columns, $data);
}
}
return $columns;
}
/**
* Given an array of data options, dispatch the necessary callback function.
*/
function filefield_data_value($key, $value) {
$info = filefield_data_info();
if (isset($info[$key]['callback'])) {
$callback = $info[$key]['callback'];
$value = $callback($value);
}
else {
$value = check_plain((string) $value);
}
return $value;
}
/**
* Implementation of hook_filefield_data_info().
*
* Define a list of values that this module stores in the "data" column of a
* file field. The callback function receives the portion of the data column
* defined by key and should return a value suitable for printing to the page.
*/
function filefield_filefield_data_info() {
return array(
'description' => array(
'title' => t('Description'),
'callback' => 'check_plain',
),
);
}
/**
* Determine the most appropriate icon for the given file's mimetype.
*
* @param $file
* A file object.
* @return
* The URL of the icon image file, or FALSE if no icon could be found.
*/
function filefield_icon_url($file) {
module_load_include('inc', 'filefield', 'filefield.theme');
return _filefield_icon_url($file);
}
/**
* Implementation of hook_filefield_icon_sets().
*
* Define a list of icon sets and directories that contain the icons.
*/
function filefield_filefield_icon_sets() {
return array(
'default' => drupal_get_path('module', 'filefield') . '/icons',
);
}
/**
* Access callback for AHAH upload/delete callbacks and node form validation.
*
* The content_permissions module provides nice fine-grained permissions for
* us to check, so we can make sure that the user may actually edit the file.
*/
function filefield_edit_access($type_name, $field_name, $node = NULL) {
return content_access('edit', content_fields($field_name, $type_name), NULL, $node);
}
/**
* Access callback that checks if the current user may view the filefield.
*/
function filefield_view_access($field_name, $node = NULL) {
return content_access('view', content_fields($field_name), NULL, $node);
}
/**
* Menu callback; Shared AHAH callback for uploads and deletions.
*
* This rebuilds the form element for a particular field item. As long as the
* form processing is properly encapsulated in the widget element the form
* should rebuild correctly using FAPI without the need for additional callbacks
* or processing.
*/
function filefield_js($type_name, $field_name, $delta) {
$field = content_fields($field_name, $type_name);
// Immediately disable devel shutdown functions so that it doesn't botch our
// JSON output.
$GLOBALS['devel_shutdown'] = FALSE;
if (empty($field) || empty($_POST['form_build_id'])) {
// Invalid request.
drupal_set_message(t('An unrecoverable error occurred. The uploaded file likely exceeded the maximum file size (@size) that this server supports.', array(
'@size' => format_size(file_upload_max_size()),
)), 'error');
print drupal_to_js(array(
'data' => theme('status_messages'),
));
exit;
}
// Build the new form.
$form_state = array(
'submitted' => FALSE,
);
$form_build_id = $_POST['form_build_id'];
$form = form_get_cache($form_build_id, $form_state);
if (!$form) {
// Invalid form_build_id.
drupal_set_message(t('An unrecoverable error occurred. This form was missing from the server cache. Try reloading the page and submitting again.'), 'error');
print drupal_to_js(array(
'data' => theme('status_messages'),
));
exit;
}
// Build the form. This calls the file field's #value_callback function and
// saves the uploaded file. Since this form is already marked as cached
// (the #cache property is TRUE), the cache is updated automatically and we
// don't need to call form_set_cache().
$args = $form['#parameters'];
$form_id = array_shift($args);
$form['#post'] = $_POST;
$form = form_builder($form_id, $form, $form_state);
// Update the cached form with the new element at the right place in the form.
if (module_exists('fieldgroup') && ($group_name = _fieldgroup_field_get_group($type_name, $field_name))) {
if (isset($form['#multigroups']) && isset($form['#multigroups'][$group_name][$field_name])) {
$form_element = $form[$group_name][$delta][$field_name];
}
else {
$form_element = $form[$group_name][$field_name][$delta];
}
}
if (!isset($form_element)) {
$form_element = $form[$field_name][$delta];
}
// Prevent duplicate wrappers
unset($form_element['#prefix'], $form_element['#suffix']);
if (isset($form_element['_weight'])) {
unset($form_element['_weight']);
}
$output = drupal_render($form_element);
// AHAH is not being nice to us and doesn't know the "other" button (that is,
// either "Upload" or "Delete") yet. Which in turn causes it not to attach
// AHAH behaviours after replacing the element. So we need to tell it first.
// Loop through the JS settings and find the settings needed for our buttons.
$javascript = drupal_add_js(NULL, NULL);
$filefield_ahah_settings = array();
if (isset($javascript['setting'])) {
foreach ($javascript['setting'] as $settings) {
if (isset($settings['ahah'])) {
foreach ($settings['ahah'] as $id => $ahah_settings) {
if (strpos($id, 'filefield-upload') || strpos($id, 'filefield-remove')) {
$filefield_ahah_settings[$id] = $ahah_settings;
}
}
}
}
}
// Add the AHAH settings needed for our new buttons.
if (!empty($filefield_ahah_settings)) {
$output .= '<script type="text/javascript">jQuery.extend(Drupal.settings.ahah, ' . drupal_to_js($filefield_ahah_settings) . ');</script>';
}
$output = theme('status_messages') . $output;
// For some reason, file uploads don't like drupal_json() with its manual
// setting of the text/javascript HTTP header. So use this one instead.
print drupal_to_js(array(
'status' => TRUE,
'data' => $output,
));
exit;
}
/**
* Menu callback for upload progress.
*/
function filefield_progress($key) {
$progress = array(
'message' => t('Starting upload...'),
'percentage' => -1,
);
$implementation = filefield_progress_implementation();
if ($implementation == 'uploadprogress') {
$status = uploadprogress_get_info($key);
if (isset($status['bytes_uploaded']) && !empty($status['bytes_total'])) {
$progress['message'] = t('Uploading... (@current of @total)', array(
'@current' => format_size($status['bytes_uploaded']),
'@total' => format_size($status['bytes_total']),
));
$progress['percentage'] = round(100 * $status['bytes_uploaded'] / $status['bytes_total']);
}
}
elseif ($implementation == 'apc') {
$status = apc_fetch('upload_' . $key);
if (isset($status['current']) && !empty($status['total'])) {
$progress['message'] = t('Uploading... (@current of @total)', array(
'@current' => format_size($status['current']),
'@total' => format_size($status['total']),
));
$progress['percentage'] = round(100 * $status['current'] / $status['total']);
}
}
drupal_json($progress);
}
/**
* Determine which upload progress implementation to use, if any available.
*/
function filefield_progress_implementation() {
static $implementation;
if (!isset($implementation)) {
$implementation = FALSE;
// We prefer the PECL extension uploadprogress because it supports multiple
// simultaneous uploads. APC only supports one at a time.
if (extension_loaded('uploadprogress')) {
$implementation = 'uploadprogress';
}
elseif (extension_loaded('apc') && ini_get('apc.rfc1867')) {
$implementation = 'apc';
}
}
return $implementation;
}
/**
* Implementation of hook_file_references().
*/
function filefield_file_references($file) {
$count = filefield_get_file_reference_count($file);
return $count ? array(
'filefield' => $count,
) : NULL;
}
/**
* Implementation of hook_file_delete().
*/
function filefield_file_delete($file) {
filefield_delete_file_references($file);
}
/**
* An #upload_validators callback. Check the file matches an allowed extension.
*
* If the mimedetect module is available, this will also validate that the
* content of the file matches the extension. User #1 is included in this check.
*
* @param $file
* A Drupal file object.
* @param $extensions
* A string with a space separated list of allowed extensions.
* @return
* An array of any errors cause by this file if it failed validation.
*/
function filefield_validate_extensions($file, $extensions) {
global $user;
$errors = array();
if (!empty($extensions)) {
$regex = '/\\.(' . preg_replace('/ +/', '|', preg_quote($extensions)) . ')$/i';
$matches = array();
if (preg_match($regex, $file->filename, $matches)) {
$extension = $matches[1];
// If the extension validates, check that the mimetype matches.
if (module_exists('mimedetect')) {
$type = mimedetect_mime($file);
if ($type != $file->filemime) {
$errors[] = t('The file contents (@type) do not match its extension (@extension).', array(
'@type' => $type,
'@extension' => $extension,
));
}
}
}
else {
$errors[] = t('Only files with the following extensions are allowed: %files-allowed.', array(
'%files-allowed' => $extensions,
));
}
}
return $errors;
}
/**
* Help text automatically appended to fields that have extension validation.
*/
function filefield_validate_extensions_help($extensions) {
if (!empty($extensions)) {
return t('Allowed extensions: %ext', array(
'%ext' => $extensions,
));
}
else {
return '';
}
}
/**
* An #upload_validators callback. Check the file size does not exceed a limit.
*
* @param $file
* A Drupal file object.
* @param $file_limit
* An integer value limiting the maximum file size in bytes.
* @param $file_limit
* An integer value limiting the maximum size in bytes a user can upload on
* the entire site.
* @return
* An array of any errors cause by this file if it failed validation.
*/
function filefield_validate_size($file, $file_limit = 0, $user_limit = 0) {
global $user;
$errors = array();
if ($file_limit && $file->filesize > $file_limit) {
$errors[] = t('The file is %filesize exceeding the maximum file size of %maxsize.', array(
'%filesize' => format_size($file->filesize),
'%maxsize' => format_size($file_limit),
));
}
// Bypass user limits for uid = 1.
if ($user->uid != 1) {
$total_size = file_space_used($user->uid) + $file->filesize;
if ($user_limit && $total_size > $user_limit) {
$errors[] = t('The file is %filesize which would exceed your disk quota of %quota.', array(
'%filesize' => format_size($file->filesize),
'%quota' => format_size($user_limit),
));
}
}
return $errors;
}
/**
* Automatic help text appended to fields that have file size validation.
*/
function filefield_validate_size_help($size) {
return t('Maximum file size: %size', array(
'%size' => format_size(parse_size($size)),
));
}
/**
* An #upload_validators callback. Check an image resolution.
*
* @param $file
* A Drupal file object.
* @param $max_size
* A string in the format WIDTHxHEIGHT. If the image is larger than this size
* the image will be scaled to fit within these dimensions.
* @param $min_size
* A string in the format WIDTHxHEIGHT. If the image is smaller than this size
* a validation error will be returned.
* @return
* An array of any errors cause by this file if it failed validation.
*/
function filefield_validate_image_resolution(&$file, $maximum_dimensions = 0, $minimum_dimensions = 0) {
$errors = array();
@(list($max_width, $max_height) = explode('x', $maximum_dimensions));
@(list($min_width, $min_height) = explode('x', $minimum_dimensions));
// Check first that the file is an image.
if ($info = image_get_info($file->filepath)) {
if ($maximum_dimensions) {
$resized = FALSE;
// Check that it is smaller than the given dimensions.
if ($info['width'] > $max_width || $info['height'] > $max_height) {
$ratio = min($max_width / $info['width'], $max_height / $info['height']);
// Check for exact dimension requirements (scaling allowed).
if (strcmp($minimum_dimensions, $maximum_dimensions) == 0 && $info['width'] / $max_width != $info['height'] / $max_height) {
$errors[] = t('The image must be exactly %dimensions pixels.', array(
'%dimensions' => $maximum_dimensions,
));
}
elseif ((image_get_toolkit() || module_exists('imageapi')) && ($info['width'] * $ratio < $min_width || $info['height'] * $ratio < $min_height)) {
$errors[] = t('The image will not fit between the dimensions of %min_dimensions and %max_dimensions pixels.', array(
'%min_dimensions' => $minimum_dimensions,
'%max_dimensions' => $maximum_dimensions,
));
}
elseif (module_exists('imageapi') && imageapi_default_toolkit()) {
$res = imageapi_image_open($file->filepath);
imageapi_image_scale($res, $max_width, $max_height);
imageapi_image_close($res, $file->filepath);
$resized = TRUE;
}
elseif (image_get_toolkit() && @image_scale($file->filepath, $file->filepath, $max_width, $max_height)) {
$resized = TRUE;
}
else {
$errors[] = t('The image is too large; the maximum dimensions are %dimensions pixels.', array(
'%dimensions' => $maximum_dimensions,
));
}
}
// Clear the cached filesize and refresh the image information.
if ($resized) {
drupal_set_message(t('The image was resized to fit within the maximum allowed dimensions of %dimensions pixels.', array(
'%dimensions' => $maximum_dimensions,
)));
clearstatcache();
$file->filesize = filesize($file->filepath);
}
}
if ($minimum_dimensions && empty($errors)) {
// Check that it is larger than the given dimensions.
if ($info['width'] < $min_width || $info['height'] < $min_height) {
$errors[] = t('The image is too small; the minimum dimensions are %dimensions pixels.', array(
'%dimensions' => $minimum_dimensions,
));
}
}
}
return $errors;
}
/**
* Automatic help text appended to fields that have image resolution validation.
*/
function filefield_validate_image_resolution_help($max_size = '0', $min_size = '0') {
if (!empty($max_size)) {
if (!empty($min_size)) {
if ($max_size == $min_size) {
return t('Images must be exactly @min_size pixels', array(
'@min_size' => $min_size,
));
}
else {
return t('Images must be between @min_size pixels and @max_size', array(
'@max_size' => $max_size,
'@min_size' => $min_size,
));
}
}
else {
if (image_get_toolkit()) {
return t('Images larger than @max_size pixels will be scaled', array(
'@max_size' => $max_size,
));
}
else {
return t('Images must be smaller than @max_size pixels', array(
'@max_size' => $max_size,
));
}
}
}
if (!empty($min_size)) {
return t('Images must be larger than @max_size pixels', array(
'@max_size' => $min_size,
));
}
}
/**
* An #upload_validators callback. Check that a file is an image.
*
* This check should allow any image that PHP can identify, including png, jpg,
* gif, tif, bmp, psd, swc, iff, jpc, jp2, jpx, jb2, xbm, and wbmp.
*
* This check should be combined with filefield_validate_extensions() to ensure
* only web-based images are allowed, however it provides a better check than
* extension checking alone if the mimedetect module is not available.
*
* @param $file
* A Drupal file object.
* @return
* An array of any errors cause by this file if it failed validation.
*/
function filefield_validate_is_image(&$file) {
$errors = array();
$info = image_get_info($file->filepath);
if (!$info || empty($info['extension'])) {
$errors[] = t('The file is not a known image format.');
}
return $errors;
}
/**
* An #upload_validators callback. Add the field to the file object.
*
* This validation function adds the field to the file object for later
* use in field aware modules implementing hook_file. It's not truly a
* validation at all, rather a convient way to add properties to the uploaded
* file.
*/
function filefield_validate_associate_field(&$file, $field) {
$file->field = $field;
return array();
}
/*******************************************************************************
* Public API functions for FileField.
******************************************************************************/
/**
* Return an array of file fields within a node type or by field name.
*
* @param $field
* Optional. May be either a field array or a field name.
* @param $node_type
* Optional. The node type to filter the list of fields.
*/
function filefield_get_field_list($node_type = NULL, $field = NULL) {
// Build the list of fields to be used for retrieval.
if (isset($field)) {
if (is_string($field)) {
$field = content_fields($field, $node_type);
}
$fields = array(
$field['field_name'] => $field,
);
}
elseif (isset($node_type)) {
$type = content_types($node_type);
$fields = $type['fields'];
}
else {
$fields = content_fields();
}
// Filter down the list just to file fields.
foreach ($fields as $key => $field) {
if ($field['type'] != 'filefield') {
unset($fields[$key]);
}
}
return $fields;
}
/**
* Count the number of times the file is referenced within a field.
*
* @param $file
* A file object.
* @param $field
* Optional. The CCK field array or field name as a string.
* @return
* An integer value.
*/
function filefield_get_file_reference_count($file, $field = NULL) {
$fields = filefield_get_field_list(NULL, $field);
$file = (object) $file;
$references = 0;
foreach ($fields as $field) {
$db_info = content_database_info($field);
$references += db_result(db_query('SELECT count(' . $db_info['columns']['fid']['column'] . ')
FROM {' . $db_info['table'] . '}
WHERE ' . $db_info['columns']['fid']['column'] . ' = %d', $file->fid));
// If a field_name is present in the file object, the file is being deleted
// from this field.
if (isset($file->field_name) && $field['field_name'] == $file->field_name) {
// If deleting the entire node, count how many references to decrement.
if (isset($file->delete_nid)) {
$node_references = db_result(db_query('SELECT count(' . $db_info['columns']['fid']['column'] . ')
FROM {' . $db_info['table'] . '}
WHERE ' . $db_info['columns']['fid']['column'] . ' = %d AND nid = %d', $file->fid, $file->delete_nid));
$references = $references - $node_references;
}
else {
$references = $references - 1;
}
}
}
return $references;
}
/**
* Get a list of node IDs that reference a file.
*
* @param $file
* The file object for which to find references.
* @param $field
* Optional. The CCK field array or field name as a string.
* @return
* An array of IDs grouped by NID: array([nid] => array([vid1], [vid2])).
*/
function filefield_get_file_references($file, $field = NULL) {
$fields = filefield_get_field_list(NULL, $field);
$file = (object) $file;
$references = array();
foreach ($fields as $field) {
$db_info = content_database_info($field);
$sql = 'SELECT nid, vid FROM {' . $db_info['table'] . '} WHERE ' . $db_info['columns']['fid']['column'] . ' = %d';
$result = db_query($sql, $file->fid);
while ($row = db_fetch_object($result)) {
$references[$row->nid][$row->vid] = $row->vid;
}
}
return $references;
}
/**
* Get all FileField files connected to a node ID.
*
* @param $node
* The node object.
* @param $field
* Optional. The CCK field array or field name as a string.
* @return
* An array of all files attached to that field (or all fields).
*/
function filefield_get_node_files($node, $field = NULL) {
$fields = filefield_get_field_list($node->type, $field);
$files = array();
// Get the file rows.
foreach ($fields as $field) {
$db_info = content_database_info($field);
$fields = 'f.*';
$fields .= ', c.' . $db_info['columns']['list']['column'] . ' AS list';
$fields .= ', c.' . $db_info['columns']['data']['column'] . ' AS data';
$sql = 'SELECT ' . $fields . ' FROM {files} f INNER JOIN {' . $db_info['table'] . '} c ON f.fid = c.' . $db_info['columns']['fid']['column'] . ' AND c.vid = %d';
$result = db_query($sql, $node->vid);
while ($file = db_fetch_array($result)) {
$file['data'] = unserialize($file['data']);
$files[$file['fid']] = $file;
}
}
return $files;
}
/**
* Delete all node references of a file.
*
* @param $file
* The file object for which to find references.
* @param $field
* Optional. The CCK field array or field name as a string.
*/
function filefield_delete_file_references($file, $field = NULL) {
$fields = filefield_get_field_list(NULL, $field);
$file = (object) $file;
$references = filefield_get_file_references($file, $field);
foreach ($references as $nid => $node_references) {
// Do not update a node if it is already being deleted directly by the user.
if (isset($file->delete_nid) && $file->delete_nid == $nid) {
continue;
}
foreach ($node_references as $vid) {
// Do not update the node revision if that revision is already being
// saved or deleted directly by the user.
if (isset($file->delete_vid) && $file->delete_vid == $vid) {
continue;
}
$node = node_load($nid, $vid);
foreach ($fields as $field_name => $field) {
if (isset($node->{$field_name})) {
foreach ($node->{$field_name} as $delta => $item) {
if ($item['fid'] == $file->fid) {
unset($node->{$field_name}[$delta]);
}
}
$node->{$field_name} = array_values(array_filter($node->{$field_name}));
}
}
// Save the node after removing the file references. This flag prevents
// FileField from attempting to delete the file again.
$node->skip_filefield_delete = TRUE;
node_save($node);
}
}
}Functions
Name |
Description |
|---|---|
| filefield_content_diff_values | Implementation of CCK's hook_content_diff_values(). |
| filefield_content_generate | Implementation of CCK's hook_content_generate(). Used by generate.module. |
| filefield_content_is_empty | Implementation of CCK's hook_content_is_empty(). |
| filefield_data_info | Get a list of possible information stored in a file field "data" column. |
| filefield_data_value | Given an array of data options, dispatch the necessary callback function. |
| filefield_default_value | Implementation of CCK's hook_default_value(). |
| filefield_delete_file_references | Delete all node references of a file. |
| filefield_edit_access | Access callback for AHAH upload/delete callbacks and node form validation. |
| filefield_elements | Implementation of hook_elements(). |
| filefield_field | Implementation of CCK's hook_field(). |
| filefield_field_formatter_info | Implementation of CCK's hook_field_formatter_info(). |
| filefield_field_info | Implementation of CCK's hook_field_info(). |
| filefield_field_settings | Implementation of hook_field_settings(). |
| filefield_filefield_data_info | Implementation of hook_filefield_data_info(). |
| filefield_filefield_icon_sets | Implementation of hook_filefield_icon_sets(). |
| filefield_file_delete | Implementation of hook_file_delete(). |
| filefield_file_download | Implementation of hook_file_download(). |
| filefield_file_references | Implementation of hook_file_references(). |
| filefield_form_alter | Implementation of hook_form_alter(). |
| filefield_get_field_list | Return an array of file fields within a node type or by field name. |
| filefield_get_file_references | Get a list of node IDs that reference a file. |
| filefield_get_file_reference_count | Count the number of times the file is referenced within a field. |
| filefield_get_node_files | Get all FileField files connected to a node ID. |
| filefield_icon_url | Determine the most appropriate icon for the given file's mimetype. |
| filefield_init | Implementation of hook_init(). |
| filefield_js | Menu callback; Shared AHAH callback for uploads and deletions. |
| filefield_menu | Implementation of hook_menu(). |
| filefield_progress | Menu callback for upload progress. |
| filefield_progress_implementation | Determine which upload progress implementation to use, if any available. |
| filefield_theme | Implementation of hook_theme(). @todo: autogenerate theme registry entrys for widgets. |
| filefield_validate_associate_field | An #upload_validators callback. Add the field to the file object. |
| filefield_validate_extensions | An #upload_validators callback. Check the file matches an allowed extension. |
| filefield_validate_extensions_help | Help text automatically appended to fields that have extension validation. |
| filefield_validate_image_resolution | An #upload_validators callback. Check an image resolution. |
| filefield_validate_image_resolution_help | Automatic help text appended to fields that have image resolution validation. |
| filefield_validate_is_image | An #upload_validators callback. Check that a file is an image. |
| filefield_validate_size | An #upload_validators callback. Check the file size does not exceed a limit. |
| filefield_validate_size_help | Automatic help text appended to fields that have file size validation. |
| filefield_views_api | Implementation of hook_views_api(). |
| filefield_view_access | Access callback that checks if the current user may view the filefield. |
| filefield_widget | Implementation of hook_widget(). |
| filefield_widget_info | Implementation of CCK's hook_widget_info(). |
| filefield_widget_settings | Implementation of CCK's hook_widget_settings(). |
| filefield_widget_upload_validators | Get the upload validators for a file field. |