Project

General

Profile

Paste
Download (88.6 KB) Statistics
| Branch: | Revision:

root / drupal7 / sites / all / modules / file_entity / file_entity.module @ 082b75eb

1
<?php
2

    
3
/**
4
 * @file
5
 * Extends Drupal file entities to be fieldable and viewable.
6
 */
7

    
8
/**
9
 * Modules should return this value from hook_file_entity_access() to allow
10
 * access to a file.
11
 */
12
define('FILE_ENTITY_ACCESS_ALLOW', 'allow');
13

    
14
/**
15
 * Modules should return this value from hook_file_entity_access() to deny
16
 * access to a file.
17
 */
18
define('FILE_ENTITY_ACCESS_DENY', 'deny');
19

    
20
/**
21
 * Modules should return this value from hook_file_entity_access() to not affect
22
 * file access.
23
 */
24
define('FILE_ENTITY_ACCESS_IGNORE', NULL);
25

    
26
/**
27
 * As part of extending Drupal core's file entity API, this module adds some
28
 * functions to the 'file' namespace. For organization, those are kept in the
29
 * 'file_entity.file_api.inc' file.
30
 */
31
require_once dirname(__FILE__) . '/file_entity.file_api.inc';
32

    
33
// @todo Remove when http://drupal.org/node/977052 is fixed.
34
require_once dirname(__FILE__) . '/file_entity.field.inc';
35

    
36
/**
37
 * Implements hook_hook_info().
38
 */
39
function file_entity_hook_info() {
40
  $hooks = array(
41
    'file_operations',
42
    'file_type_info',
43
    'file_type_info_alter',
44
    'file_formatter_info',
45
    'file_formatter_info_alter',
46
    'file_view',
47
    'file_view_alter',
48
    'file_displays_alter',
49
    'file_type',
50
    'file_type_alter',
51
    'file_download_headers_alter',
52
    'file_entity_access',
53
  );
54

    
55
  return array_fill_keys($hooks, array('group' => 'file'));
56
}
57

    
58
/**
59
 * Implements hook_hook_info_alter().
60
 *
61
 * Add support for existing core hooks to be located in modulename.file.inc.
62
 */
63
function file_entity_hook_info_alter(&$info) {
64
  $hooks = array(
65
    // File API hooks
66
    'file_copy',
67
    'file_move',
68
    'file_validate',
69
    // File access
70
    'file_download',
71
    'file_download_access',
72
    'file_download_access_alter',
73
    // File entity hooks
74
    'file_load',
75
    'file_presave',
76
    'file_insert',
77
    'file_update',
78
    'file_delete',
79
    // Miscellaneous hooks
80
    'file_mimetype_mapping_alter',
81
    'file_url_alter',
82
    // Stream wrappers
83
    'stream_wrappers',
84
    'stream_wrappers_alter',
85
  );
86
  $info += array_fill_keys($hooks, array('group' => 'file'));
87
}
88

    
89
/**
90
 * Implements hook_module_implements_alter().
91
 */
92
function file_entity_module_implements_alter(&$implementations, $hook) {
93
  // nginx_accel_redirect_file_transfer() is an accidental hook implementation.
94
  // @see https://www.drupal.org/node/2278625
95
  if ($hook == 'file_transfer') {
96
    unset($implementations['nginx_accel_redirect']);
97
  }
98
}
99

    
100
/**
101
 * Implements hook_help().
102
 */
103
function file_entity_help($path, $arg) {
104
  switch ($path) {
105
    case 'admin/structure/file-types':
106
      $output = '<p>' . t('When a file is uploaded to this website, it is assigned one of the following types, based on what kind of file it is.') . '</p>';
107
      return $output;
108
    case 'admin/structure/file-types/manage/%/display/preview':
109
    case 'admin/structure/file-types/manage/%/file-display/preview':
110
      drupal_set_message(t('Some modules rely on the Preview view mode to function correctly. Changing these settings may break parts of your site.'), 'warning');
111
      break;
112
  }
113
}
114

    
115
/**
116
 * Implements hook_menu().
117
 */
118
function file_entity_menu() {
119
  // File Configuration
120
  // @todo Move this back to admin/config/media/file-types in Drupal 8 if
121
  // MENU_MAX_DEPTH is increased to a value higher than 9.
122
  $items['admin/structure/file-types'] = array(
123
    'title' => 'File types',
124
    'description' => 'Manage settings for the type of files used on your site.',
125
    'page callback' => 'file_entity_list_types_page',
126
    'access arguments' => array('administer file types'),
127
    'file' => 'file_entity.admin.inc',
128
  );
129
  $items['admin/structure/file-types/add'] = array(
130
    'title' => 'Add file type',
131
    'page callback' => 'drupal_get_form',
132
    'page arguments' => array('file_entity_file_type_form'),
133
    'access arguments' => array('administer file types'),
134
    'type' => MENU_LOCAL_ACTION,
135
    'file' => 'file_entity.admin.inc',
136
  );
137
  $items['admin/structure/file-types/manage/%file_type'] = array(
138
    'title' => 'Manage file types',
139
    'description' => 'Manage settings for the type of files used on your site.',
140
  );
141
  $items['admin/structure/file-types/manage/%file_type/enable'] = array(
142
    'title' => 'Enable',
143
    'page callback' => 'drupal_get_form',
144
    'page arguments' => array('file_entity_type_enable_confirm', 4),
145
    'access arguments' => array('administer file types'),
146
    'file' => 'file_entity.admin.inc',
147
    'type' => MENU_CALLBACK,
148
  );
149
  $items['admin/structure/file-types/manage/%file_type/disable'] = array(
150
    'title' => 'Disable',
151
    'page callback' => 'drupal_get_form',
152
    'page arguments' => array('file_entity_type_disable_confirm', 4),
153
    'access arguments' => array('administer file types'),
154
    'file' => 'file_entity.admin.inc',
155
    'type' => MENU_CALLBACK,
156
  );
157
  $items['admin/structure/file-types/manage/%file_type/revert'] = array(
158
    'title' => 'Revert',
159
    'page callback' => 'drupal_get_form',
160
    'page arguments' => array('file_entity_type_revert_confirm', 4),
161
    'access arguments' => array('administer file types'),
162
    'file' => 'file_entity.admin.inc',
163
    'type' => MENU_CALLBACK,
164
  );
165
  $items['admin/structure/file-types/manage/%file_type/delete'] = array(
166
    'title' => 'Delete',
167
    'page callback' => 'drupal_get_form',
168
    'page arguments' => array('file_entity_type_delete_confirm', 4),
169
    'access arguments' => array('administer file types'),
170
    'file' => 'file_entity.admin.inc',
171
    'type' => MENU_CALLBACK,
172
  );
173

    
174
  $items['admin/content/file'] = array(
175
    'title' => 'Files',
176
    'description' => 'Manage files used on your site.',
177
    'page callback' => 'drupal_get_form',
178
    'page arguments' => array('file_entity_admin_file'),
179
    'access arguments' => array('administer files'),
180
    'type' => MENU_LOCAL_TASK | MENU_NORMAL_ITEM,
181
    'file' => 'file_entity.admin.inc',
182
  );
183
  $items['admin/content/file/list'] = array(
184
    'title' => 'List',
185
    'type' => MENU_DEFAULT_LOCAL_TASK,
186
  );
187

    
188
  // general view, edit, delete for files
189
  $items['file/add'] = array(
190
    'title' => 'Add file',
191
    'page callback' => 'drupal_get_form',
192
    'page arguments' => array('file_entity_add_upload', array()),
193
    'access callback' => 'file_entity_access',
194
    'access arguments' => array('create'),
195
    'file' => 'file_entity.pages.inc',
196
  );
197
  if (module_exists('plupload') && module_exists('multiform')) {
198
    $items['file/add']['page arguments'] = array('file_entity_add_upload_multiple');
199
  }
200
  $items['file/add/upload'] = array(
201
    'title' => 'Upload',
202
    'type' => MENU_DEFAULT_LOCAL_TASK,
203
    'weight' => -10,
204
  );
205
  $items['file/add/upload/file'] = array(
206
    'title' => 'File',
207
    'type' => MENU_DEFAULT_LOCAL_TASK,
208
    'weight' => -10,
209
  );
210
  $items['file/add/upload/archive'] = array(
211
    'title' => 'Archive',
212
    'page callback' => 'drupal_get_form',
213
    'page arguments' => array('file_entity_upload_archive_form'),
214
    'access arguments' => array('administer files'),
215
    'file' => 'file_entity.pages.inc',
216
    'type' => MENU_LOCAL_TASK,
217
    'weight' => -5,
218
  );
219
  $items['file/%file'] = array(
220
    'title callback' => 'entity_label',
221
    'title arguments' => array('file', 1),
222
    // The page callback also invokes drupal_set_title() in case
223
    // the menu router's title is overridden by a menu link.
224
    'page callback' => 'file_entity_view_page',
225
    'page arguments' => array(1),
226
    'access callback' => 'file_entity_access',
227
    'access arguments' => array('view', 1),
228
    'file' => 'file_entity.pages.inc',
229
  );
230
  $items['file/%file/view'] = array(
231
    'title' => 'View',
232
    'type' => MENU_DEFAULT_LOCAL_TASK,
233
    'weight' => -10,
234
  );
235
  $items['file/%file/usage'] = array(
236
    'title' => 'Usage',
237
    'page callback' => 'file_entity_usage_page',
238
    'page arguments' => array(1),
239
    'access callback' => 'file_entity_access',
240
    'access arguments' => array('update', 1),
241
    'type' => MENU_LOCAL_TASK,
242
    'context' => MENU_CONTEXT_PAGE,
243
    'file' => 'file_entity.pages.inc',
244
  );
245
  $items['file/%file/download'] = array(
246
    'title' => 'Download',
247
    'page callback' => 'file_entity_download_page',
248
    'page arguments' => array(1),
249
    'access callback' => 'file_entity_access',
250
    'access arguments' => array('download', 1),
251
    'file' => 'file_entity.pages.inc',
252
    'type' => MENU_CALLBACK,
253
  );
254
  $items['file/%file/edit'] = array(
255
    'title' => 'Edit',
256
    'page callback' => 'drupal_get_form',
257
    'page arguments' => array('file_entity_edit', 1),
258
    'access callback' => 'file_entity_access',
259
    'access arguments' => array('update', 1),
260
    'weight' => 0,
261
    'type' => MENU_LOCAL_TASK,
262
    'context' => MENU_CONTEXT_PAGE | MENU_CONTEXT_INLINE,
263
    'file' => 'file_entity.pages.inc',
264
  );
265
  $items['file/%file/delete'] = array(
266
    'title' => 'Delete',
267
    'page callback' => 'drupal_get_form',
268
    'page arguments'  => array('file_entity_delete_form', 1),
269
    'access callback' => 'file_entity_access',
270
    'access arguments' => array('delete', 1),
271
    'weight' => 1,
272
    'type' => MENU_LOCAL_TASK,
273
    'context' => MENU_CONTEXT_PAGE | MENU_CONTEXT_INLINE,
274
    'file' => 'file_entity.pages.inc',
275
  );
276

    
277
  // Attach a "Manage file display" tab to each file type in the same way that
278
  // Field UI attaches "Manage fields" and "Manage display" tabs. Note that
279
  // Field UI does not have to be enabled; we're just using the same IA pattern
280
  // here for attaching the "Manage file display" page.
281
  $entity_info = entity_get_info('file');
282
  foreach ($entity_info['bundles'] as $file_type => $bundle_info) {
283
    if (isset($bundle_info['admin'])) {
284
      // Get the base path and access.
285
      $path = $bundle_info['admin']['path'];
286
      $access = array_intersect_key($bundle_info['admin'], drupal_map_assoc(array('access callback', 'access arguments')));
287
      $access += array(
288
        'access callback' => 'user_access',
289
        'access arguments' => array('administer file types'),
290
      );
291

    
292
      // The file type must be passed to the page callbacks. It might be
293
      // configured as a wildcard (multiple file types sharing the same menu
294
      // router path).
295
      $file_type_argument = isset($bundle_info['admin']['bundle argument']) ? $bundle_info['admin']['bundle argument'] : $file_type;
296

    
297
      $items[$path] = array(
298
        'title' => 'Edit file type',
299
        'title callback' => 'file_entity_type_get_name',
300
        'title arguments' => array(4),
301
        'page callback' => 'drupal_get_form',
302
        'page arguments' => array('file_entity_file_type_form', $file_type_argument),
303
        'file' => 'file_entity.admin.inc',
304
      ) + $access;
305

    
306
      // Add the 'File type settings' tab.
307
      $items["$path/edit"] = array(
308
        'title' => 'Edit',
309
        'type' => MENU_DEFAULT_LOCAL_TASK,
310
      );
311

    
312
      // Add the 'Manage file display' tab.
313
      $items["$path/file-display"] = array(
314
        'title' => 'Manage file display',
315
        'page callback' => 'drupal_get_form',
316
        'page arguments' => array('file_entity_file_display_form', $file_type_argument, 'default'),
317
        'type' => MENU_LOCAL_TASK,
318
        'weight' => 3,
319
        'file' => 'file_entity.admin.inc',
320
      ) + $access;
321

    
322
      // Add a secondary tab for each view mode.
323
      $weight = 0;
324
      $view_modes = array('default' => array('label' => t('Default'))) + $entity_info['view modes'];
325
      foreach ($view_modes as $view_mode => $view_mode_info) {
326
        $items["$path/file-display/$view_mode"] = array(
327
          'title' => $view_mode_info['label'],
328
          'page arguments' => array('file_entity_file_display_form', $file_type_argument, $view_mode),
329
          'type' => ($view_mode == 'default' ? MENU_DEFAULT_LOCAL_TASK : MENU_LOCAL_TASK),
330
          'weight' => ($view_mode == 'default' ? -10 : $weight++),
331
          'file' => 'file_entity.admin.inc',
332
          // View modes for which the 'custom settings' flag isn't TRUE are
333
          // disabled via this access callback. This needs to extend, rather
334
          // than override normal $access rules.
335
          'access callback' => '_file_entity_view_mode_menu_access',
336
          'access arguments' => array_merge(array($file_type_argument, $view_mode, $access['access callback']), $access['access arguments']),
337
        );
338
      }
339
    }
340
  }
341

    
342
  $items['admin/config/media/file-settings'] = array(
343
    'title' => 'File settings',
344
    'description' => 'Configure allowed file extensions, default alt and title sources, and the file upload wizard.',
345
    'page callback' => 'drupal_get_form',
346
    'page arguments' => array('file_entity_settings_form'),
347
    'access arguments' => array('administer site configuration'),
348
    'file' => 'file_entity.admin.inc',
349
  );
350

    
351
  // Optional devel module integration
352
  if (module_exists('devel')) {
353
    $items['file/%file/devel'] = array(
354
      'title' => 'Devel',
355
      'page callback' => 'devel_load_object',
356
      'page arguments' => array('file', 1),
357
      'access arguments' => array('access devel information'),
358
      'type' => MENU_LOCAL_TASK,
359
      'file' => 'devel.pages.inc',
360
      'file path' => drupal_get_path('module', 'devel'),
361
      'weight' => 100,
362
    );
363
    $items['file/%file/devel/load'] = array(
364
      'title' => 'Load',
365
      'type' => MENU_DEFAULT_LOCAL_TASK,
366
    );
367
    $items['file/%file/devel/render'] = array(
368
      'title' => 'Render',
369
      'page callback' => 'devel_render_object',
370
      'page arguments' => array('file', 1),
371
      'access arguments' => array('access devel information'),
372
      'file' => 'devel.pages.inc',
373
      'file path' => drupal_get_path('module', 'devel'),
374
      'type' => MENU_LOCAL_TASK,
375
      'weight' => 100,
376
    );
377
    if (module_exists('token')) {
378
      $items['file/%file/devel/token'] = array(
379
        'title' => 'Tokens',
380
        'page callback' => 'token_devel_token_object',
381
        'page arguments' => array('file', 1),
382
        'access arguments' => array('access devel information'),
383
        'type' => MENU_LOCAL_TASK,
384
        'file' => 'token.pages.inc',
385
        'file path' => drupal_get_path('module', 'token'),
386
        'weight' => 5,
387
      );
388
    }
389
  }
390

    
391
  // Devel generate integration.
392
  if (module_exists('devel_generate')) {
393
    $items['admin/config/development/generate/file'] = array(
394
      'title' => 'Generate files',
395
      'description' => 'Generate a given number of files. Optionally delete current files.',
396
      'page callback' => 'drupal_get_form',
397
      'page arguments' => array('file_entity_generate_file_form'),
398
      'access arguments' => array('administer files'),
399
      'file' => 'file_entity.devel_generate.inc',
400
    );
401
    $items['admin/content/file/generate'] = $items['admin/config/development/generate/file'];
402
    $items['admin/content/file/generate']['type'] = MENU_LOCAL_ACTION;
403
    $items['file/add/generate'] = $items['admin/config/development/generate/file'];
404
    $items['file/add/generate']['title'] = 'Generate';
405
    $items['file/add/generate']['type'] = MENU_LOCAL_TASK;
406
    $items['file/add/generate']['weight'] = 50;
407
  }
408

    
409
  return $items;
410
}
411

    
412
/**
413
 * Implements hook_menu_local_tasks_alter().
414
 */
415
function file_entity_menu_local_tasks_alter(&$data, $router_item, $root_path) {
416
  // Add action link to 'file/add' on 'admin/content/file' page.
417
  if ($root_path == 'admin/content/file') {
418
    $item = menu_get_item('file/add');
419
    if (!empty($item['access'])) {
420
      $data['actions']['output'][] = array(
421
        '#theme' => 'menu_local_action',
422
        '#link' => $item,
423
        '#weight' => $item['weight'],
424
      );
425
    }
426
  }
427
}
428

    
429
/**
430
 * Implement hook_permission().
431
 */
432
function file_entity_permission() {
433
  $permissions = array(
434
    'bypass file access' => array(
435
      'title' => t('Bypass file access control'),
436
      'description' => t('View, edit and delete all files regardless of permission restrictions.'),
437
      'restrict access' => TRUE,
438
    ),
439
    'administer file types' => array(
440
      'title' => t('Administer file types'),
441
      'restrict access' => TRUE,
442
    ),
443
    'administer files' => array(
444
      'title' => t('Administer files'),
445
      'restrict access' => TRUE,
446
    ),
447
    'create files' => array(
448
      'title' => t('Add and upload new files'),
449
    ),
450
    'view own private files' => array(
451
      'title' => t('View own private files'),
452
    ),
453
    'view own files' => array(
454
      'title' => t('View own files'),
455
    ),
456
    'view private files' => array(
457
      'title' => t('View private files'),
458
      'restrict access' => TRUE,
459
    ),
460
    'view files' => array(
461
      'title' => t('View files'),
462
    ),
463
  );
464

    
465
  // Add description for the 'View file details' and 'View own private file
466
  // details' permissions to show which stream wrappers they apply to.
467
  $wrappers = file_entity_get_public_and_private_stream_wrapper_names();
468
  $wrappers += array('public' => array(t('None')), 'private' => array(t('None')));
469

    
470
  $permissions['view files']['description'] = t('Includes the following stream wrappers: %wrappers.', array('%wrappers' => implode(', ', $wrappers['public'])));
471
  $permissions['view own private files']['description'] = t('Includes the following stream wrappers: %wrappers.', array('%wrappers' => implode(', ', $wrappers['private'])));
472

    
473
  // Generate standard file permissions for all applicable file types.
474
  foreach (file_entity_permissions_get_configured_types() as $type) {
475
    $permissions += file_entity_list_permissions($type);
476
  }
477

    
478
  return $permissions;
479
}
480

    
481
/*
482
 * Implements hook_cron_queue_info().
483
 */
484
function file_entity_cron_queue_info() {
485
  $queues['file_entity_type_determine'] = array(
486
    'worker callback' => 'file_entity_type_determine',
487
  );
488
  return $queues;
489
}
490

    
491
/*
492
 * Determines file type for a given file ID and saves the file.
493
 *
494
 * @param $fid
495
 *   A file ID.
496
 */
497
function file_entity_type_determine($fid) {
498
  if ($file = file_load($fid)) {
499
    // The file type will be automatically determined when saving the file.
500
    file_save($file);
501
  }
502
}
503

    
504
/**
505
 * Gather the rankings from the the hook_ranking implementations.
506
 *
507
 * @param $query
508
 *   A query object that has been extended with the Search DB Extender.
509
 */
510
function _file_entity_rankings(SelectQueryExtender $query) {
511
  if ($ranking = module_invoke_all('file_ranking')) {
512
    $tables = &$query->getTables();
513
    foreach ($ranking as $rank => $values) {
514
      if ($file_rank = variable_get('file_entity_rank_' . $rank, 0)) {
515
        // If the table defined in the ranking isn't already joined, then add it.
516
        if (isset($values['join']) && !isset($tables[$values['join']['alias']])) {
517
          $query->addJoin($values['join']['type'], $values['join']['table'], $values['join']['alias'], $values['join']['on']);
518
        }
519
        $arguments = isset($values['arguments']) ? $values['arguments'] : array();
520
        $query->addScore($values['score'], $arguments, $file_rank);
521
      }
522
    }
523
  }
524
}
525

    
526
/**
527
 * Implements hook_search_info().
528
 */
529
function file_entity_search_info() {
530
  return array(
531
    'title' => 'Files',
532
    'path' => 'file',
533
  );
534
}
535

    
536
/**
537
 * Implements hook_search_access().
538
 */
539
function file_entity_search_access() {
540
  return user_access('view own private files') || user_access('view own files') || user_access('view private files') || user_access('view files');
541
}
542

    
543
/**
544
 * Implements hook_search_reset().
545
 */
546
function file_entity_search_reset() {
547
  db_update('search_dataset')
548
    ->fields(array('reindex' => REQUEST_TIME))
549
    ->condition('type', 'file')
550
    ->execute();
551
}
552

    
553
/**
554
 * Implements hook_search_status().
555
 */
556
function file_entity_search_status() {
557
  $total = db_query('SELECT COUNT(*) FROM {file_managed}')->fetchField();
558
  $remaining = db_query("SELECT COUNT(*) FROM {file_managed} fm LEFT JOIN {search_dataset} d ON d.type = 'file' AND d.sid = fm.fid WHERE d.sid IS NULL OR d.reindex <> 0")->fetchField();
559
  return array('remaining' => $remaining, 'total' => $total);
560
}
561

    
562
/**
563
 * Implements hook_search_admin().
564
 */
565
function file_entity_search_admin() {
566
  // Output form for defining rank factor weights.
567
  $form['file_ranking'] = array(
568
    '#type' => 'fieldset',
569
    '#title' => t('File ranking'),
570
  );
571
  $form['file_ranking']['#theme'] = 'file_entity_search_admin';
572
  $form['file_ranking']['info'] = array(
573
    '#value' => '<em>' . t('The following numbers control which properties the file search should favor when ordering the results. Higher numbers mean more influence, zero means the property is ignored. Changing these numbers does not require the search index to be rebuilt. Changes take effect immediately.') . '</em>'
574
  );
575

    
576
  // Note: reversed to reflect that higher number = higher ranking.
577
  $options = drupal_map_assoc(range(0, 10));
578
  foreach (module_invoke_all('file_ranking') as $var => $values) {
579
    $form['file_ranking']['factors']['file_entity_rank_' . $var] = array(
580
      '#title' => $values['title'],
581
      '#type' => 'select',
582
      '#options' => $options,
583
      '#default_value' => variable_get('file_entity_rank_' . $var, 0),
584
    );
585
  }
586
  return $form;
587
}
588

    
589
/**
590
 * Implements hook_search_execute().
591
 */
592
function file_entity_search_execute($keys = NULL, $conditions = NULL) {
593
  global $user;
594

    
595
  // Build matching conditions
596
  $query = db_select('search_index', 'i', array('target' => 'slave'))->extend('SearchQuery')->extend('PagerDefault');
597
  $query->join('file_managed', 'fm', 'fm.fid = i.sid');
598
  $query->searchExpression($keys, 'file');
599

    
600
  // Insert special keywords.
601
  $query->setOption('type', 'fm.type');
602
  if ($query->setOption('term', 'ti.tid')) {
603
    $query->join('taxonomy_index', 'ti', 'fm.fid = ti.fid');
604
  }
605
  // Only continue if the first pass query matches.
606
  if (!$query->executeFirstPass()) {
607
    return array();
608
  }
609

    
610
  // Add the ranking expressions.
611
  _file_entity_rankings($query);
612

    
613
  // Load results.
614
  $find = $query
615
    ->limit(10)
616
    ->addTag('file_access')
617
    ->execute();
618
  $results = array();
619
  foreach ($find as $item) {
620
    // Render the file.
621
    $file = file_load($item->sid);
622
    $build = file_view($file, 'search_result');
623
    unset($build['#theme']);
624
    $file->rendered = drupal_render($build);
625

    
626
    $extra = module_invoke_all('file_entity_search_result', $file);
627

    
628
    $types = file_entity_type_get_names();
629

    
630
    $uri = entity_uri('file', $file);
631
    $results[] = array(
632
      'link' => url($uri['path'], array_merge($uri['options'], array('absolute' => TRUE))),
633
      'type' => check_plain($types[$file->type]),
634
      'title' => $file->filename,
635
      'user' => theme('username', array('account' => user_load($file->uid))),
636
      'date' => $file->timestamp,
637
      'file' => $file,
638
      'extra' => $extra,
639
      'score' => $item->calculated_score,
640
      'snippet' => search_excerpt($keys, $file->rendered),
641
      'language' => function_exists('entity_language') ? entity_language('file', $file) : NULL,
642
    );
643
  }
644
  return $results;
645
}
646

    
647
/**
648
 * Implements hook_file_ranking().
649
 */
650
function file_entity_file_ranking() {
651
  // Create the ranking array and add the basic ranking options.
652
  $ranking = array(
653
    'relevance' => array(
654
      'title' => t('Keyword relevance'),
655
      // Average relevance values hover around 0.15
656
      'score' => 'i.relevance',
657
    ),
658
  );
659

    
660
  // Add relevance based on creation date.
661
  if ($file_cron_last = variable_get('file_entity_cron_last', 0)) {
662
    $ranking['timestamp'] = array(
663
      'title' => t('Recently posted'),
664
      // Exponential decay with half-life of 6 months, starting at last indexed file
665
      'score' => 'POW(2.0, (fm.timestamp - :file_cron_last) * 6.43e-8)',
666
      'arguments' => array(':file_cron_last' => $file_cron_last),
667
    );
668
  }
669
  return $ranking;
670
}
671

    
672
/**
673
 * Returns HTML for the file ranking part of the search settings admin page.
674
 *
675
 * @param $variables
676
 *   An associative array containing:
677
 *   - form: A render element representing the form.
678
 *
679
 * @ingroup themeable
680
 */
681
function theme_file_entity_search_admin($variables) {
682
  $form = $variables['form'];
683

    
684
  $output = drupal_render($form['info']);
685

    
686
  $header = array(t('Factor'), t('Weight'));
687
  foreach (element_children($form['factors']) as $key) {
688
    $row = array();
689
    $row[] = $form['factors'][$key]['#title'];
690
    $form['factors'][$key]['#title_display'] = 'invisible';
691
    $row[] = drupal_render($form['factors'][$key]);
692
    $rows[] = $row;
693
  }
694
  $output .= theme('table', array('header' => $header, 'rows' => $rows));
695

    
696
  $output .= drupal_render_children($form);
697
  return $output;
698
}
699

    
700
/**
701
 * Implements hook_update_index().
702
 */
703
function file_entity_update_index() {
704
  $limit = (int)variable_get('search_cron_limit', 100);
705

    
706
  $result = db_query_range("SELECT fm.fid FROM {file_managed} fm LEFT JOIN {search_dataset} d ON d.type = 'file' AND d.sid = fm.fid WHERE d.sid IS NULL OR d.reindex <> 0 ORDER BY d.reindex ASC, fm.fid ASC", 0, $limit, array(), array('target' => 'slave'));
707

    
708
  foreach ($result as $file) {
709
    _file_entity_index_file($file);
710
  }
711
}
712

    
713
/**
714
 * Index a single file.
715
 *
716
 * @param $file
717
 *   The file to index.
718
 */
719
function _file_entity_index_file($file) {
720
  $file = file_load($file->fid);
721

    
722
  // Save the creation time of the most recent indexed file, for the search
723
  // results half-life calculation.
724
  variable_set('file_entity_cron_last', $file->timestamp);
725

    
726
  // Render the file.
727
  $build = file_view($file, 'search_index');
728
  unset($build['#theme']);
729
  $file->rendered = drupal_render($build);
730

    
731
  $text = '<h1>' . check_plain($file->filename) . '</h1>' . $file->rendered;
732

    
733
  // Fetch extra data normally not visible
734
  $extra = module_invoke_all('file_entity_update_index', $file);
735
  foreach ($extra as $t) {
736
    $text .= $t;
737
  }
738

    
739
  // Update index
740
  search_index($file->fid, 'file', $text);
741
}
742

    
743
/**
744
 * Implements hook_form_FORM_ID_alter().
745
 */
746
function file_entity_form_search_form_alter(&$form, $form_state) {
747
  if (isset($form['module']) && $form['module']['#value'] == 'file_entity' && user_access('use advanced search')) {
748
    // Keyword boxes:
749
    $form['advanced'] = array(
750
      '#type' => 'fieldset',
751
      '#title' => t('Advanced search'),
752
      '#collapsible' => TRUE,
753
      '#collapsed' => TRUE,
754
      '#attributes' => array('class' => array('search-advanced')),
755
    );
756
    $form['advanced']['keywords'] = array(
757
      '#prefix' => '<div class="criterion">',
758
      '#suffix' => '</div>',
759
    );
760
    $form['advanced']['keywords']['or'] = array(
761
      '#type' => 'textfield',
762
      '#title' => t('Containing any of the words'),
763
      '#size' => 30,
764
      '#maxlength' => 255,
765
    );
766
    $form['advanced']['keywords']['phrase'] = array(
767
      '#type' => 'textfield',
768
      '#title' => t('Containing the phrase'),
769
      '#size' => 30,
770
      '#maxlength' => 255,
771
    );
772
    $form['advanced']['keywords']['negative'] = array(
773
      '#type' => 'textfield',
774
      '#title' => t('Containing none of the words'),
775
      '#size' => 30,
776
      '#maxlength' => 255,
777
    );
778

    
779
    // File types:
780
    $types = array_map('check_plain', file_entity_type_get_names());
781
    $form['advanced']['type'] = array(
782
      '#type' => 'checkboxes',
783
      '#title' => t('Only of the type(s)'),
784
      '#prefix' => '<div class="criterion">',
785
      '#suffix' => '</div>',
786
      '#options' => $types,
787
    );
788
    $form['advanced']['submit'] = array(
789
      '#type' => 'submit',
790
      '#value' => t('Advanced search'),
791
      '#prefix' => '<div class="action">',
792
      '#suffix' => '</div>',
793
      '#weight' => 100,
794
    );
795

    
796
    $form['#validate'][] = 'file_entity_search_validate';
797
  }
798
}
799

    
800
/**
801
 * Form API callback for the search form. Registered in file_entity_form_alter().
802
 */
803
function file_entity_search_validate($form, &$form_state) {
804
  // Initialize using any existing basic search keywords.
805
  $keys = $form_state['values']['processed_keys'];
806

    
807
  // Insert extra restrictions into the search keywords string.
808
  if (isset($form_state['values']['type']) && is_array($form_state['values']['type'])) {
809
    // Retrieve selected types - Form API sets the value of unselected
810
    // checkboxes to 0.
811
    $form_state['values']['type'] = array_filter($form_state['values']['type']);
812
    if (count($form_state['values']['type'])) {
813
      $keys = search_expression_insert($keys, 'type', implode(',', array_keys($form_state['values']['type'])));
814
    }
815
  }
816

    
817
  if (isset($form_state['values']['term']) && is_array($form_state['values']['term']) && count($form_state['values']['term'])) {
818
    $keys = search_expression_insert($keys, 'term', implode(',', $form_state['values']['term']));
819
  }
820
  if ($form_state['values']['or'] != '') {
821
    if (preg_match_all('/ ("[^"]+"|[^" ]+)/i', ' ' . $form_state['values']['or'], $matches)) {
822
      $keys .= ' ' . implode(' OR ', $matches[1]);
823
    }
824
  }
825
  if ($form_state['values']['negative'] != '') {
826
    if (preg_match_all('/ ("[^"]+"|[^" ]+)/i', ' ' . $form_state['values']['negative'], $matches)) {
827
      $keys .= ' -' . implode(' -', $matches[1]);
828
    }
829
  }
830
  if ($form_state['values']['phrase'] != '') {
831
    $keys .= ' "' . str_replace('"', ' ', $form_state['values']['phrase']) . '"';
832
  }
833
  if (!empty($keys)) {
834
    form_set_value($form['basic']['processed_keys'], trim($keys), $form_state);
835
  }
836
}
837

    
838
/**
839
 * Implements hook_admin_paths().
840
 */
841
function file_entity_admin_paths() {
842
  $paths = array(
843
    'file/add' => TRUE,
844
    'file/add/*' => TRUE,
845
    'file/*/edit' => TRUE,
846
    'file/*/usage' => TRUE,
847
    'file/*/delete' => TRUE,
848
  );
849
  return $paths;
850
}
851

    
852
/**
853
 * Implements hook_action_info_alter().
854
 */
855
function file_entity_action_info_alter(&$actions) {
856
  if (module_exists('pathauto')) {
857
    $actions['pathauto_file_update_action'] = array(
858
      'type' => 'file',
859
      'label' => t('Update file alias'),
860
      'configurable' => FALSE,
861
    );
862
  }
863
}
864

    
865
/**
866
 * Implements hook_theme().
867
 */
868
function file_entity_theme() {
869
  return array(
870
    'file_entity' => array(
871
      'render element' => 'elements',
872
      'template' => 'file_entity',
873
    ),
874
    'file_entity_search_admin' => array(
875
      'render element' => 'form',
876
    ),
877
    'file_entity_file_type_overview' => array(
878
      'variables' => array('label' => NULL, 'description' => NULL),
879
      'file' => 'file_entity.admin.inc',
880
    ),
881
    'file_entity_file_display_order' => array(
882
      'render element' => 'element',
883
      'file' => 'file_entity.admin.inc',
884
    ),
885
    'file_entity_file_link' => array(
886
      'variables' => array('file' => NULL, 'icon_directory' => NULL),
887
      'file' => 'file_entity.theme.inc',
888
    ),
889
    'file_entity_download_link' => array(
890
      'variables' => array('file' => NULL, 'icon_directory' => NULL, 'text' => NULL),
891
      'file' => 'file_entity.theme.inc',
892
    ),
893
    'file_entity_file_audio' => array(
894
      'variables' => array(
895
        'files' => array(),
896
        'controls' => TRUE,
897
        'controls_list' => array(
898
          'download' => 'download',
899
          'remote_playback' => 'remote_playback',
900
        ),
901
        'autoplay' => FALSE,
902
        'loop' => FALSE,
903
        'preload' => NULL,
904
      ),
905
      'file' => 'file_entity.theme.inc',
906
    ),
907
    'file_entity_file_video' => array(
908
      'variables' => array(
909
        'files' => array(),
910
        'controls' => TRUE,
911
        'controls_list' => array(
912
          'fullscreen' => 'fullscreen',
913
          'download' => 'download',
914
          'remote_playback' => 'remote_playback',
915
        ),
916
        'autoplay' => FALSE,
917
        'loop' => FALSE,
918
        'muted' => FALSE,
919
        'width' => NULL,
920
        'height' => NULL,
921
        'preload' => NULL,
922
      ),
923
      'file' => 'file_entity.theme.inc',
924
    ),
925
  );
926
}
927

    
928
/**
929
 * Implements hook_entity_info_alter().
930
 *
931
 * Extends the core file entity to be fieldable. The file type is used as the
932
 * bundle key. File types are implemented as CTools exportables, so modules can
933
 * define default file types via hook_file_default_types(), and the
934
 * administrator can override the default types or add custom ones via
935
 * admin/structure/file-types.
936
 */
937
function file_entity_entity_info_alter(&$entity_info) {
938
  $entity_info['file']['fieldable'] = TRUE;
939
  $entity_info['file']['entity keys']['bundle'] = 'type';
940
  $entity_info['file']['bundle keys']['bundle'] = 'type';
941
  $entity_info['file']['bundles'] = array();
942
  $entity_info['file']['uri callback'] = 'file_entity_uri';
943
  $entity_info['file']['view modes']['teaser'] = array(
944
    'label' => t('Teaser'),
945
    'custom settings' => TRUE,
946
  );
947
  $entity_info['file']['view modes']['full'] = array(
948
    'label' => t('Full content'),
949
    'custom settings' => FALSE,
950
  );
951
  $entity_info['file']['view modes']['preview'] = array(
952
    'label' => t('Preview'),
953
    'custom settings' => TRUE,
954
  );
955
  $entity_info['file']['view modes']['rss'] = array(
956
    'label' => t('RSS'),
957
    'custom settings' => FALSE,
958
  );
959

    
960
  // Search integration is provided by file_entity.module, so search-related
961
  // view modes for files are defined here and not in search.module.
962
  if (module_exists('search')) {
963
    $entity_info['file']['view modes']['search_index'] = array(
964
      'label' => t('Search index'),
965
      'custom settings' => FALSE,
966
    );
967
    $entity_info['file']['view modes']['search_result'] = array(
968
      'label' => t('Search result'),
969
      'custom settings' => FALSE,
970
    );
971
  }
972

    
973
  foreach (file_type_get_enabled_types() as $type) {
974
    $entity_info['file']['bundles'][$type->type] = array(
975
      'label' => $type->label,
976
      'admin' => array(
977
        'path' => 'admin/structure/file-types/manage/%file_type',
978
        'real path' => 'admin/structure/file-types/manage/' . $type->type,
979
        'bundle argument' => 4,
980
        'access arguments' => array('administer file types'),
981
      ),
982
    );
983
  }
984

    
985
  // Enable Metatag support.
986
  $entity_info['file']['metatags'] = TRUE;
987

    
988
  // Ensure some of the Entity API callbacks are supported.
989
  $entity_info['file']['creation callback'] = 'entity_metadata_create_object';
990
  $entity_info['file']['view callback'] = 'file_entity_metadata_view_file';
991
  $entity_info['file']['form callback'] = 'file_entity_metadata_form_file';
992
  $entity_info['file']['access callback'] = 'file_entity_access';
993

    
994
  // Add integration with the Title module for file name replacement support.
995
  $entity_info['file']['field replacement'] = array(
996
    'filename' => array(
997
      'field' => array(
998
        'type' => 'text',
999
        'cardinality' => 1,
1000
        'translatable' => TRUE,
1001
      ),
1002
      'instance' => array(
1003
        'label' => t('File name'),
1004
        'description' => t('A field replacing file name.'),
1005
        'required' => TRUE,
1006
        'settings' => array(
1007
          'text_processing' => 0,
1008
        ),
1009
        'widget' => array(
1010
          'weight' => -5,
1011
        ),
1012
        'display' => array(
1013
          'default' => array(
1014
            'type' => 'hidden',
1015
          ),
1016
        ),
1017
      ),
1018
      'preprocess_key' => 'filename',
1019
    ),
1020
  );
1021
}
1022

    
1023
/**
1024
 * Implements hook_entity_property_info().
1025
 */
1026
function file_entity_entity_property_info() {
1027
  $info['file']['properties']['type'] = array(
1028
    'label' => t('File type'),
1029
    'type' => 'token',
1030
    'description' => t('The type of the file.'),
1031
    'setter callback' => 'entity_property_verbatim_set',
1032
    'setter permission' => 'administer files',
1033
    'options list' => 'file_entity_type_get_names',
1034
    'required' => TRUE,
1035
    'schema field' => 'type',
1036
  );
1037

    
1038
  return $info;
1039
}
1040

    
1041
/**
1042
 * Implements hook_field_display_ENTITY_TYPE_alter().
1043
 */
1044
function file_entity_field_display_file_alter(&$display, $context) {
1045
  // Hide field labels in search index.
1046
  if ($context['view_mode'] == 'search_index') {
1047
    $display['label'] = 'hidden';
1048
  }
1049
}
1050

    
1051
/**
1052
 * URI callback for file entities.
1053
 */
1054
function file_entity_uri($file) {
1055
  $uri['path'] = 'file/' . $file->fid;
1056
  return $uri;
1057
}
1058

    
1059
/**
1060
 * Entity API callback to view files.
1061
 */
1062
function file_entity_metadata_view_file($entities, $view_mode = 'full', $langcode = NULL) {
1063
  $result = file_view_multiple($entities, $view_mode, 0, $langcode);
1064
  // Make sure to key the result with 'file' instead of 'files'.
1065
  return array('file' => reset($result));
1066
}
1067

    
1068
/**
1069
 * Entity API callback to get the form of a file entity.
1070
 */
1071
function file_entity_metadata_form_file($file) {
1072
  // Pre-populate the form-state with the right form include.
1073
  $form_state['build_info']['args'] = array($file);
1074
  form_load_include($form_state, 'inc', 'file_entity', 'file_entity.pages');
1075
  return drupal_build_form('file_entity_edit', $form_state);
1076
}
1077

    
1078
/**
1079
 * Implements hook_ctools_plugin_directory().
1080
 */
1081
function file_entity_ctools_plugin_directory($module, $plugin) {
1082
  if (in_array($module, array('panelizer', 'ctools', 'page_manager'))) {
1083
    return 'plugins/' . $plugin;
1084
  }
1085
}
1086

    
1087
/**
1088
 * Implements hook_field_extra_fields().
1089
 *
1090
 * Adds 'file' as an extra field, so that its display and form component can be
1091
 * weighted relative to the fields that are added to file entity bundles.
1092
 */
1093
function file_entity_field_extra_fields() {
1094
  $info = array();
1095

    
1096
  if ($file_type_names = file_entity_type_get_names()) {
1097
    foreach ($file_type_names as $type => $name) {
1098
      $info['file'][$type]['form']['filename'] = array(
1099
        'label' => t('File name'),
1100
        'description' => t('File name'),
1101
        'weight' => -10,
1102
      );
1103
      $info['file'][$type]['form']['preview'] = array(
1104
        'label' => t('File'),
1105
        'description' => t('File preview'),
1106
        'weight' => -5,
1107
      );
1108
      $info['file'][$type]['display']['file'] = array(
1109
        'label' => t('File'),
1110
        'description' => t('File display'),
1111
        'weight' => 0,
1112
      );
1113
    }
1114
  }
1115

    
1116
  return $info;
1117
}
1118

    
1119
/**
1120
 * Implements hook_file_formatter_info().
1121
 */
1122
function file_entity_file_formatter_info() {
1123
  $formatters = array();
1124

    
1125
  // Allow file field formatters to be reused for displaying the file entity's
1126
  // file pseudo-field.
1127
  foreach (field_info_formatter_types() as $key => $formatter) {
1128
    if (array_intersect($formatter['field types'], array('file', 'image'))) {
1129
      $key = 'file_field_' . $key;
1130
      $formatters[$key] = array(
1131
        'label' => $formatter['label'],
1132
        'description' => !empty($formatter['description']) ? $formatter['description'] : '',
1133
        'view callback' => 'file_entity_file_formatter_file_field_view',
1134
      );
1135
      if (!empty($formatter['settings'])) {
1136
        $formatters[$key] += array(
1137
          'default settings' => $formatter['settings'],
1138
          'settings callback' => 'file_entity_file_formatter_file_field_settings',
1139
        );
1140
      }
1141
      if (!empty($formatter['file formatter'])) {
1142
        $formatters[$key] += $formatter['file formatter'];
1143
      }
1144
    }
1145
  }
1146

    
1147
  // Add a simple file formatter for displaying an image in a chosen style.
1148
  if (module_exists('image')) {
1149
    $formatters['file_image'] = array(
1150
      'label' => t('Image'),
1151
      'default settings' => array(
1152
        'image_style' => '',
1153
        'alt' => '[file:field-file-image-alt-text]',
1154
        'title' => '[file:field-file-image-title-text]'
1155
      ),
1156
      'view callback' => 'file_entity_file_formatter_file_image_view',
1157
      'settings callback' => 'file_entity_file_formatter_file_image_settings',
1158
      'hidden' => TRUE,
1159
      'mime types' => array('image/*'),
1160
    );
1161
  }
1162

    
1163
  return $formatters;
1164
}
1165

    
1166
/**
1167
 * Implements hook_file_formatter_FORMATTER_view().
1168
 *
1169
 * This function provides a bridge to the field formatter API, so that file
1170
 * field formatters can be reused for displaying the file entity's file
1171
 * pseudo-field.
1172
 */
1173
function file_entity_file_formatter_file_field_view($file, $display, $langcode) {
1174
  if (strpos($display['type'], 'file_field_') === 0) {
1175
    $field_formatter_type = substr($display['type'], strlen('file_field_'));
1176
    $field_formatter_info = field_info_formatter_types($field_formatter_type);
1177
    if (isset($field_formatter_info['module'])) {
1178
      // Set $display['type'] to what hook_field_formatter_*() expects.
1179
      $display['type'] = $field_formatter_type;
1180

    
1181
      // Allow any attribute overrides (e.g. from the Media module) to be
1182
      // respected.
1183
      $item = (array) $file;
1184
      if (!empty($file->override['attributes'])) {
1185
        $item = array_merge($item, $file->override['attributes']);
1186
      }
1187

    
1188
      // Set $items to what file field formatters expect. See file_field_load(),
1189
      // and note that, here, $file is already a fully loaded entity.
1190
      $items = array($item);
1191

    
1192
      // Invoke hook_field_formatter_prepare_view() and
1193
      // hook_field_formatter_view(). Note that we are reusing field formatter
1194
      // functions, but we are not displaying a Field API field, so we set
1195
      // $field and $instance accordingly, and do not invoke
1196
      // hook_field_prepare_view(). This assumes that the formatter functions do
1197
      // not rely on $field or $instance. A module that implements formatter
1198
      // functions that rely on $field or $instance (and therefore, can only be
1199
      // used for real fields) can prevent this formatter from being used on the
1200
      // pseudo-field by removing it within hook_file_formatter_info_alter().
1201
      $field = $instance = NULL;
1202
      if (($function = ($field_formatter_info['module'] . '_field_formatter_prepare_view')) && function_exists($function)) {
1203
        $fid = $file->fid;
1204
        // hook_field_formatter_prepare_view() alters $items by reference.
1205
        $grouped_items = array($fid => &$items);
1206
        $function('file', array($fid => $file), $field, array($fid => $instance), $langcode, $grouped_items, array($fid => $display));
1207
      }
1208
      if (($function = ($field_formatter_info['module'] . '_field_formatter_view')) && function_exists($function)) {
1209
        $element = $function('file', $file, $field, $instance, $langcode, $items, $display);
1210
        // We passed the file as $items[0], so return the corresponding element.
1211
        if (isset($element[0])) {
1212
          return $element[0];
1213
        }
1214
      }
1215
    }
1216
  }
1217
}
1218

    
1219
/**
1220
 * Implements hook_file_formatter_FORMATTER_settings().
1221
 *
1222
 * This function provides a bridge to the field formatter API, so that file
1223
 * field formatters can be reused for displaying the file entity's file
1224
 * pseudo-field.
1225
 */
1226
function file_entity_file_formatter_file_field_settings($form, &$form_state, $settings, $formatter_type, $file_type, $view_mode) {
1227
  if (strpos($formatter_type, 'file_field_') === 0) {
1228
    $field_formatter_type = substr($formatter_type, strlen('file_field_'));
1229
    $field_formatter_info = field_info_formatter_types($field_formatter_type);
1230

    
1231
    // Invoke hook_field_formatter_settings_form(). We are reusing field
1232
    // formatter functions, but we are not working with a Field API field, so
1233
    // set $field accordingly. Unfortunately, the API is for $settings to be
1234
    // transferred via the $instance parameter, so we must mock it.
1235
    if (isset($field_formatter_info['module']) && ($function = ($field_formatter_info['module'] . '_field_formatter_settings_form')) && function_exists($function)) {
1236
      $field = NULL;
1237
      $mock_instance = array(
1238
        'display' => array(
1239
          $view_mode => array(
1240
            'type' => $field_formatter_type,
1241
            'settings' => $settings,
1242
          ),
1243
        ),
1244
        'entity_type' => 'file',
1245
        'bundle' => $file_type,
1246
      );
1247
      return $function($field, $mock_instance, $view_mode, $form, $form_state);
1248
    }
1249
  }
1250
}
1251

    
1252
/**
1253
 * Implements hook_file_formatter_FORMATTER_view().
1254
 *
1255
 * Returns a drupal_render() array to display an image of the chosen style.
1256
 *
1257
 * This formatter is only capable of displaying local images. If the passed in
1258
 * file is either not local or not an image, nothing is returned, so that
1259
 * file_view_file() can try another formatter.
1260
 */
1261
function file_entity_file_formatter_file_image_view($file, $display, $langcode) {
1262
  // Prevent PHP notices when trying to read empty files.
1263
  // @see http://drupal.org/node/681042
1264
  if (!$file->filesize) {
1265
    return;
1266
  }
1267

    
1268
  // Do not bother proceeding if this file does not have an image mime type.
1269
  if (file_entity_file_get_mimetype_type($file) != 'image') {
1270
    return;
1271
  }
1272

    
1273
  if (file_entity_file_is_readable($file)) {
1274
    // We don't sanitize here.
1275
    // @see http://drupal.org/node/1553094#comment-6257382
1276
    // Theme function will take care of escaping.
1277
    if (!isset($file->metadata)) {
1278
      $file->metadata = array();
1279
    }
1280
    $file->metadata += array('width' => NULL, 'height' => NULL);
1281
    $replace_options = array(
1282
      'clear' => TRUE,
1283
      'sanitize' => FALSE,
1284
    );
1285
    if (!empty($display['settings']['image_style'])) {
1286
      $element = array(
1287
        '#theme' => 'image_style',
1288
        '#style_name' => $display['settings']['image_style'],
1289
        '#path' => $file->uri,
1290
        '#width' => isset($file->override['attributes']['width']) ? $file->override['attributes']['width'] : $file->metadata['width'],
1291
        '#height' => isset($file->override['attributes']['height']) ? $file->override['attributes']['height'] : $file->metadata['height'],
1292
        '#alt' => token_replace($display['settings']['alt'], array('file' => $file), $replace_options),
1293
        '#title' => token_replace($display['settings']['title'], array('file' => $file), $replace_options),
1294
      );
1295
    }
1296
    else {
1297
      $element = array(
1298
        '#theme' => 'image',
1299
        '#path' => $file->uri,
1300
        '#width' => isset($file->override['attributes']['width']) ? $file->override['attributes']['width'] : $file->metadata['width'],
1301
        '#height' => isset($file->override['attributes']['height']) ? $file->override['attributes']['height'] : $file->metadata['height'],
1302
        '#alt' => token_replace($display['settings']['alt'], array('file' => $file), $replace_options),
1303
        '#title' => token_replace($display['settings']['title'], array('file' => $file), $replace_options),
1304
      );
1305
    }
1306
    return $element;
1307
  }
1308
}
1309

    
1310
/**
1311
 * Check if a file entity is readable or not.
1312
 *
1313
 * @param object $file
1314
 *   A file entity object from file_load().
1315
 *
1316
 * @return boolean
1317
 *   TRUE if the file is using a readable stream wrapper, or FALSE otherwise.
1318
 */
1319
function file_entity_file_is_readable($file) {
1320
  $scheme = file_uri_scheme($file->uri);
1321
  $wrappers = file_get_stream_wrappers(STREAM_WRAPPERS_READ);
1322
  return !empty($wrappers[$scheme]);
1323
}
1324

    
1325
/**
1326
 * Implements hook_file_formatter_FORMATTER_settings().
1327
 *
1328
 * Returns form elements for configuring the 'file_image' formatter.
1329
 */
1330
function file_entity_file_formatter_file_image_settings($form, &$form_state, $settings) {
1331
  $element = array();
1332
  $element['image_style'] = array(
1333
    '#title' => t('Image style'),
1334
    '#type' => 'select',
1335
    '#options' => image_style_options(FALSE),
1336
    '#default_value' => $settings['image_style'],
1337
    '#empty_option' => t('None (original image)'),
1338
  );
1339

    
1340
  // For image files we allow the alt attribute (required in HTML).
1341
  $element['alt'] = array(
1342
    '#title' => t('Alt attribute'),
1343
    '#description' => t('The text to use as value for the <em>img</em> tag <em>alt</em> attribute.'),
1344
    '#type' => 'textfield',
1345
    '#default_value' => $settings['alt'],
1346
  );
1347

    
1348
  // Allow the setting of the title attribute.
1349
  $element['title'] = array(
1350
    '#title' => t('Title attribute'),
1351
    '#description' => t('The text to use as value for the <em>img</em> tag <em>title</em> attribute.'),
1352
    '#type' => 'textfield',
1353
    '#default_value' => $settings['title'],
1354
  );
1355

    
1356
  if (module_exists('token')) {
1357
    $element['alt']['#description'] .= t('This field supports tokens.');
1358
    $element['title']['#description'] .= t('This field supports tokens.');
1359
    $element['tokens'] = array(
1360
      '#theme' => 'token_tree',
1361
      '#token_types' => array('file'),
1362
      '#dialog' => TRUE,
1363
    );
1364
  }
1365

    
1366
  return $element;
1367
}
1368

    
1369
/**
1370
 * Menu access callback for the 'view mode file display settings' pages.
1371
 *
1372
 * Based on _field_ui_view_mode_menu_access(), but the Field UI module might not
1373
 * be enabled.
1374
 */
1375
function _file_entity_view_mode_menu_access($file_type, $view_mode, $access_callback) {
1376
  // Deny access if the view mode isn't configured to use custom display
1377
  // settings.
1378
  $view_mode_settings = field_view_mode_settings('file', $file_type->type);
1379
  $visibility = ($view_mode == 'default') || !empty($view_mode_settings[$view_mode]['custom_settings']);
1380
  if (!$visibility) {
1381
    return FALSE;
1382
  }
1383

    
1384
  // Otherwise, continue to an $access_callback check.
1385
  $args = array_slice(func_get_args(), 3);
1386
  $callback = empty($access_callback) ? 0 : trim($access_callback);
1387
  if (is_numeric($callback)) {
1388
    return (bool) $callback;
1389
  }
1390
  elseif (function_exists($access_callback)) {
1391
    return call_user_func_array($access_callback, $args);
1392
  }
1393
}
1394

    
1395
/**
1396
 * Implements hook_modules_enabled().
1397
 */
1398
function file_entity_modules_enabled($modules) {
1399
  file_info_cache_clear();
1400
}
1401

    
1402
/**
1403
 * Implements hook_modules_disabled().
1404
 */
1405
function file_entity_modules_disabled($modules) {
1406
  file_info_cache_clear();
1407
}
1408

    
1409
/**
1410
 * Implements hook_views_api().
1411
 */
1412
function file_entity_views_api() {
1413
  return array(
1414
    'api' => 3,
1415
  );
1416
}
1417

    
1418
/**
1419
 * Returns whether the current page is the full page view of the passed-in file.
1420
 *
1421
 * @param $file
1422
 *   A file object.
1423
 */
1424
function file_entity_is_page($file) {
1425
  $page_file = menu_get_object('file', 1);
1426
  return (!empty($page_file) ? $page_file->fid == $file->fid : FALSE);
1427
}
1428

    
1429
/**
1430
 * Process variables for file_entity.tpl.php
1431
 *
1432
 * The $variables array contains the following arguments:
1433
 * - $file
1434
 * - $view_mode
1435
 *
1436
 * @see file_entity.tpl.php
1437
 */
1438
function template_preprocess_file_entity(&$variables) {
1439
  $view_mode = $variables['view_mode'] = $variables['elements']['#view_mode'];
1440
  $variables['file'] = $variables['elements']['#file'];
1441
  $file = $variables['file'];
1442

    
1443
  $variables['id'] = drupal_html_id('file-'. $file->fid);
1444
  $variables['date']      = format_date($file->timestamp);
1445
  $account = user_load($file->uid);
1446
  $variables['name']      = theme('username', array('account' => $account));
1447

    
1448
  $uri = entity_uri('file', $file);
1449
  $variables['file_url']  = url($uri['path'], $uri['options']);
1450
  $label = entity_label('file', $file);
1451
  $variables['label']     = check_plain($label);
1452
  $variables['page']      = $view_mode == 'full' && file_entity_is_page($file);
1453

    
1454
  // Hide the file name from being displayed until we can figure out a better
1455
  // way to control this. We cannot simply not output the title since
1456
  // contextual links require $title_suffix to be output in the template.
1457
  // @see http://drupal.org/node/1245266
1458
  if (!$variables['page']) {
1459
    $variables['title_attributes_array']['class'][] = 'element-invisible';
1460
  }
1461

    
1462
  // Flatten the file object's member fields.
1463
  $variables = array_merge((array) $file, $variables);
1464

    
1465
  // Helpful $content variable for templates.
1466
  $variables += array('content' => array());
1467
  foreach (element_children($variables['elements']) as $key) {
1468
    $variables['content'][$key] = $variables['elements'][$key];
1469
  }
1470

    
1471
  // Make the field variables available with the appropriate language.
1472
  field_attach_preprocess('file', $file, $variables['content'], $variables);
1473

    
1474
  // Attach the file object to the content element.
1475
  $variables['content']['file']['#file'] = $file;
1476

    
1477
  // Display post information only on certain file types.
1478
  if (variable_get('file_submitted_' . $file->type, FALSE)) {
1479
    $variables['display_submitted'] = TRUE;
1480
    $variables['submitted'] = t('Uploaded by !username on !datetime', array('!username' => $variables['name'], '!datetime' => $variables['date']));
1481
    $variables['user_picture'] = theme_get_setting('toggle_file_user_picture') ? theme('user_picture', array('account' => $account)) : '';
1482
  }
1483
  else {
1484
    $variables['display_submitted'] = FALSE;
1485
    $variables['submitted'] = '';
1486
    $variables['user_picture'] = '';
1487
  }
1488

    
1489
  // Gather file classes.
1490
  $variables['classes_array'][] = drupal_html_class('file-' . $file->type);
1491
  $variables['classes_array'][] = drupal_html_class('file-' . $file->filemime);
1492
  if ($file->status != FILE_STATUS_PERMANENT) {
1493
    $variables['classes_array'][] = 'file-temporary';
1494
  }
1495

    
1496
  // Change the 'file-entity' class into 'file'
1497
  if ($variables['classes_array'][0] == 'file-entity') {
1498
    $variables['classes_array'][0] = 'file';
1499
  }
1500

    
1501
  // Clean up name so there are no underscores.
1502
  $variables['theme_hook_suggestions'][] = 'file__' . $file->type;
1503
  $variables['theme_hook_suggestions'][] = 'file__' . $file->type . '__' . $view_mode;
1504
  $variables['theme_hook_suggestions'][] = 'file__' . str_replace(array('/', '-'), array('__', '_'), $file->filemime);
1505
  $variables['theme_hook_suggestions'][] = 'file__' . str_replace(array('/', '-'), array('__', '_'), $file->filemime) . '__' . $view_mode;
1506
  $variables['theme_hook_suggestions'][] = 'file__' . $file->fid;
1507
  $variables['theme_hook_suggestions'][] = 'file__' . $file->fid . '__' . $view_mode;
1508
}
1509

    
1510
/**
1511
 * Returns the file type name of the passed file or file type string.
1512
 *
1513
 * @param $file
1514
 *   A file object or string that indicates the file type to return.
1515
 *
1516
 * @return
1517
 *   The file type name or FALSE if the file type is not found.
1518
 */
1519
function file_entity_type_get_name($file) {
1520
  $type = is_object($file) ? $file->type : $file;
1521
  $info = entity_get_info('file');
1522
  return isset($info['bundles'][$type]['label']) ? $info['bundles'][$type]['label'] : FALSE;
1523
}
1524

    
1525
/**
1526
 * Returns a list of available file type names.
1527
 *
1528
 * @return
1529
 *   An array of file type names, keyed by the type.
1530
 */
1531
function file_entity_type_get_names() {
1532
  $names = &drupal_static(__FUNCTION__);
1533

    
1534
  if (!isset($names)) {
1535
    $names = array();
1536
    $info = entity_get_info('file');
1537
    foreach ($info['bundles'] as $bundle => $bundle_info) {
1538
      $names[$bundle] = $bundle_info['label'];
1539
    }
1540
  }
1541

    
1542
  return $names;
1543
}
1544

    
1545
/**
1546
 * Return an array of available view modes for file entities.
1547
 */
1548
function file_entity_view_mode_labels() {
1549
  $labels = &drupal_static(__FUNCTION__);
1550

    
1551
  if (!isset($options)) {
1552
    $entity_info = entity_get_info('file');
1553
    $labels = array('default' => t('Default'));
1554
    foreach ($entity_info['view modes'] as $machine_name => $mode) {
1555
      $labels[$machine_name] = $mode['label'];
1556
    }
1557
  }
1558

    
1559
  return $labels;
1560
}
1561

    
1562
/**
1563
 * Return the label for a specific file entity view mode.
1564
 */
1565
function file_entity_view_mode_label($view_mode, $default = FALSE) {
1566
  $labels = file_entity_view_mode_labels();
1567
  return isset($labels[$view_mode]) ? $labels[$view_mode] : $default;
1568
}
1569

    
1570
/**
1571
 * Helper function to get a list of hidden stream wrappers.
1572
 *
1573
 * This is used in several places to filter queries for media so that files in
1574
 * temporary:// don't show up.
1575
 */
1576
function file_entity_get_hidden_stream_wrappers() {
1577
  return array_diff_key(file_get_stream_wrappers(STREAM_WRAPPERS_ALL), file_get_stream_wrappers(STREAM_WRAPPERS_VISIBLE));
1578
}
1579

    
1580
/**
1581
 * Return a specific stream wrapper's registry information.
1582
 *
1583
 * @param $scheme
1584
 *   A URI scheme, a stream is referenced as "scheme://target".
1585
 *
1586
 * @see file_get_stream_wrappers()
1587
 */
1588
function file_entity_get_stream_wrapper($scheme) {
1589
  $wrappers = file_get_stream_wrappers();
1590
  return isset($wrappers[$scheme]) ? $wrappers[$scheme] : FALSE;
1591
}
1592

    
1593
/**
1594
 * Implements hook_stream_wrappers_alter().
1595
 */
1596
function file_entity_stream_wrappers_alter(&$wrappers) {
1597
  if (isset($wrappers['private'])) {
1598
    $wrappers['private']['private'] = TRUE;
1599
  }
1600
  if (isset($wrappers['temporary'])) {
1601
    $wrappers['temporary']['private'] = TRUE;
1602
  }
1603
}
1604

    
1605
/**
1606
 * Implements hook_ctools_plugin_api().
1607
 */
1608
function file_entity_ctools_plugin_api($module, $api) {
1609
  if (($module == 'file_entity' && $api == 'file_type') || ($module == 'page_manager' && $api == 'pages_default') || $module == 'panelizer') {
1610
    return array('version' => 1);
1611
  }
1612
  if ($module == 'file_entity' && $api == 'file_default_displays') {
1613
    return array('version' => 1);
1614
  }
1615
}
1616

    
1617
/**
1618
 * @defgroup file_entity_access File access rights
1619
 * @{
1620
 * The file access system determines who can do what to which files.
1621
 *
1622
 * In determining access rights for a file, file_entity_access() first checks
1623
 * whether the user has the "bypass file access" permission. Such users have
1624
 * unrestricted access to all files. user 1 will always pass this check.
1625
 *
1626
 * Next, all implementations of hook_file_entity_access() will be called. Each
1627
 * implementation may explicitly allow, explicitly deny, or ignore the access
1628
 * request. If at least one module says to deny the request, it will be rejected.
1629
 * If no modules deny the request and at least one says to allow it, the request
1630
 * will be permitted.
1631
 *
1632
 * There is no access grant system for files.
1633
 *
1634
 * In file listings, the process above is followed except that
1635
 * hook_file_entity_access() is not called on each file for performance reasons
1636
 * and for proper functioning of the pager system. When adding a filelisting to
1637
 * your module, be sure to use a dynamic query created by db_select()
1638
 * and add a tag of "file_entity_access". This will allow modules dealing
1639
 * with file access to ensure only files to which the user has access
1640
 * are retrieved, through the use of hook_query_TAG_alter().
1641
 *
1642
 * Note: Even a single module returning FILE_ENTITY_ACCESS_DENY from
1643
 * hook_file_entity_access() will block access to the file. Therefore,
1644
 * implementers should take care to not deny access unless they really intend to.
1645
 * Unless a module wishes to actively deny access it should return
1646
 * FILE_ENTITY_ACCESS_IGNORE (or simply return nothing)
1647
 * to allow other modules to control access.
1648
 *
1649
 * Stream wrappers that are considered private should implement a 'private'
1650
 * flag equal to TRUE in hook_stream_wrappers().
1651
 */
1652

    
1653
/**
1654
 * Determine if a user may perform the given operation on the specified file.
1655
 *
1656
 * @param $op
1657
 *   The operation to be performed on the file. Possible values are:
1658
 *   - "view"
1659
 *   - "download"
1660
 *   - "update"
1661
 *   - "delete"
1662
 *   - "create"
1663
 * @param $file
1664
 *   The file object on which the operation is to be performed, or file type
1665
 *   (e.g. 'image') for "create" operation.
1666
 * @param $account
1667
 *   Optional, a user object representing the user for whom the operation is to
1668
 *   be performed. Determines access for a user other than the current user.
1669
 *
1670
 * @return
1671
 *   TRUE if the operation may be performed, FALSE otherwise.
1672
 */
1673
function file_entity_access($op, $file = NULL, $account = NULL) {
1674
  $rights = &drupal_static(__FUNCTION__, array());
1675

    
1676
  if (!$file && !in_array($op, array('view', 'download', 'update', 'delete', 'create'), TRUE)) {
1677
    // If there was no file to check against, and the $op was not one of the
1678
    // supported ones, we return access denied.
1679
    return FALSE;
1680
  }
1681

    
1682
  // If no user object is supplied, the access check is for the current user.
1683
  if (empty($account)) {
1684
    $account = $GLOBALS['user'];
1685
  }
1686

    
1687
  // $file may be either an object or a file type. Since file types cannot be
1688
  // an integer, use either fid or type as the static cache id.
1689
  $cache_id = NULL;
1690
  if (is_object($file) && !empty($file->fid)) {
1691
    $cache_id = $file->fid;
1692
  }
1693
  elseif ($op == 'create' && is_string($file)) {
1694
    $cache_id = $file;
1695
  }
1696
  elseif ($op == 'create' && is_object($file) && !empty($file->type)) {
1697
    $cache_id = $file->type;
1698
  }
1699
  else {
1700
    $cache_id = drupal_hash_base64(serialize($file));
1701
  }
1702

    
1703
  // If we've already checked access for this file, user and op, return from
1704
  // cache.
1705
  if (isset($rights[$account->uid][$cache_id][$op])) {
1706
    return $rights[$account->uid][$cache_id][$op];
1707
  }
1708

    
1709
  if (user_access('bypass file access', $account)) {
1710
    return $rights[$account->uid][$cache_id][$op] = TRUE;
1711
  }
1712

    
1713
  // We grant access to the file if both of the following conditions are met:
1714
  // - No modules say to deny access.
1715
  // - At least one module says to grant access.
1716
  $access = module_invoke_all('file_entity_access', $op, $file, $account);
1717
  if (in_array(FILE_ENTITY_ACCESS_DENY, $access, TRUE)) {
1718
    return $rights[$account->uid][$cache_id][$op] = FALSE;
1719
  }
1720
  elseif (in_array(FILE_ENTITY_ACCESS_ALLOW, $access, TRUE)) {
1721
    return $rights[$account->uid][$cache_id][$op] = TRUE;
1722
  }
1723

    
1724

    
1725
  // Fall back to default behaviors on view.
1726
  if ($op == 'view' && is_object($file)) {
1727
    $scheme = file_uri_scheme($file->uri);
1728
    $wrapper = file_entity_get_stream_wrapper($scheme);
1729

    
1730
    if (!empty($wrapper['private'])) {
1731
      // For private files, users can view private files if the
1732
      // user has the 'view private files' permission.
1733
      if (user_access('view private files', $account)) {
1734
        return $rights[$account->uid][$cache_id][$op] = TRUE;
1735
      }
1736

    
1737
      // For private files, users can view their own private files if the
1738
      // user is not anonymous, and has the 'view own private files' permission.
1739
      if (!empty($account->uid) && $file->uid == $account->uid && user_access('view own private files', $account)) {
1740
        return $rights[$account->uid][$cache_id][$op] = TRUE;
1741
      }
1742
    }
1743
    elseif ($file->status == FILE_STATUS_PERMANENT && $file->uid == $account->uid && user_access('view own files', $account)) {
1744
      // For non-private files, allow to see if user owns the file.
1745
      return $rights[$account->uid][$cache_id][$op] = TRUE;
1746
    }
1747
    elseif ($file->status == FILE_STATUS_PERMANENT && user_access('view files', $account)) {
1748
      // For non-private files, users can view if they have the 'view files'
1749
      // permission.
1750
      return $rights[$account->uid][$cache_id][$op] = TRUE;
1751
    }
1752
  }
1753

    
1754
  return FALSE;
1755
}
1756

    
1757
/**
1758
 * Implements hook_file_entity_access().
1759
 */
1760
function file_entity_file_entity_access($op, $file, $account) {
1761
  // If the op is "create," all that's needed is to check the create permission.
1762
  if ($op == 'create') {
1763
    if (user_access('create files')) {
1764
      return FILE_ENTITY_ACCESS_ALLOW;
1765
    }
1766
  }
1767
  // If the file URI is invalid, deny access.
1768
  if (is_object($file) && isset($file->uri) && !file_valid_uri($file->uri)) {
1769
    if(isset($file->is_new) && $file->is_new == true && user_access('create files')) {
1770
      return FILE_ENTITY_ACCESS_ALLOW;
1771
    }
1772
    return FILE_ENTITY_ACCESS_DENY;
1773
  }
1774

    
1775
  if (!empty($file)) {
1776
    $type = is_string($file) ? $file : $file->type;
1777

    
1778
    if (in_array($type, file_entity_permissions_get_configured_types())) {
1779
      if ($op == 'download') {
1780
        if (user_access('download any ' . $type . ' files', $account) || is_object($file) && user_access('download own ' . $type . ' files', $account) && ($account->uid == $file->uid)) {
1781
          return FILE_ENTITY_ACCESS_ALLOW;
1782
        }
1783
      }
1784

    
1785
      if ($op == 'update') {
1786
        if (user_access('edit any ' . $type . ' files', $account) || (is_object($file) && user_access('edit own ' . $type . ' files', $account) && ($account->uid == $file->uid))) {
1787
          return FILE_ENTITY_ACCESS_ALLOW;
1788
        }
1789
      }
1790

    
1791
      if ($op == 'delete') {
1792
        if (user_access('delete any ' . $type . ' files', $account) || (is_object($file) && user_access('delete own ' . $type . ' files', $account) && ($account->uid == $file->uid))) {
1793
          return FILE_ENTITY_ACCESS_ALLOW;
1794
        }
1795
      }
1796
    }
1797
  }
1798

    
1799
  return FILE_ENTITY_ACCESS_IGNORE;
1800
}
1801

    
1802
/**
1803
 * Implements hook_query_TAG_alter().
1804
 *
1805
 * This is the hook_query_alter() for queries tagged with 'file_access'. It adds
1806
 * file access checks for the user account given by the 'account' meta-data (or
1807
 * global $user if not provided).
1808
 */
1809
function file_entity_query_file_access_alter(QueryAlterableInterface $query) {
1810
  _file_entity_query_file_entity_access_alter($query, 'file');
1811
}
1812

    
1813
/**
1814
 * Implements hook_query_TAG_alter().
1815
 *
1816
 * This function implements the same functionality as
1817
 * file_entity_query_file_access_alter() for the SQL field storage engine. File
1818
 * access conditions are added for field values belonging to files only.
1819
 */
1820
function file_entity_query_entity_field_access_alter(QueryAlterableInterface $query) {
1821
  //_file_entity_query_file_entity_access_alter($query, 'entity');
1822
}
1823

    
1824
/**
1825
 * Helper for file entity access functions.
1826
 *
1827
 * @param $query
1828
 *   The query to add conditions to.
1829
 * @param $type
1830
 *   Either 'file' or 'entity' depending on what sort of query it is. See
1831
 *   file_entity_query_file_entity_access_alter() and
1832
 *   file_entity_query_entity_field_access_alter() for more.
1833
 */
1834
function _file_entity_query_file_entity_access_alter($query, $type) {
1835
  global $user;
1836

    
1837
  // Read meta-data from query, if provided.
1838
  if (!$account = $query->getMetaData('account')) {
1839
    $account = $user;
1840
  }
1841

    
1842
  // If $account can bypass file access, we don't need to alter the query.
1843
  if (user_access('bypass file access', $account)) {
1844
    return;
1845
  }
1846

    
1847
  // A conflict with og_query_og_membership_alter() causes a fatal error
1848
  // if both hooks alter the query.
1849
  if (module_exists('og') && $query->hasTag('og_membership')) {
1850
    foreach($query->getMetaData('entity_field_query')->fields as $field) {
1851
      if (og_is_group_audience_field($field['field_name'])) {
1852
        return;
1853
      }
1854
    }
1855
  }
1856

    
1857
  $tables = $query->getTables();
1858
  $base_table = $query->getMetaData('base_table');
1859
  // If no base table is specified explicitly, search for one.
1860
  if (!$base_table) {
1861
    $fallback = '';
1862
    foreach ($tables as $alias => $table_info) {
1863
      if (!($table_info instanceof SelectQueryInterface || $table_info['table'] instanceof SelectQueryInterface)) {
1864
        $table = $table_info['table'];
1865
        // If the file_managed table is in the query, it wins immediately.
1866
        if ($table == 'file_managed') {
1867
          $base_table = $table;
1868
          break;
1869
        }
1870
        // Check whether the table has a foreign key to file_managed.fid. If it
1871
        // does, do not run this check again as we found a base table and only
1872
        // file_managed can triumph that.
1873
        if (!$base_table) {
1874
          // The schema is cached.
1875
          $schema = drupal_get_schema($table);
1876
          if (isset($schema['fields']['fid'])) {
1877
            if (isset($schema['foreign keys'])) {
1878
              foreach ($schema['foreign keys'] as $relation) {
1879
                if ($relation['table'] === 'file_managed' && $relation['columns'] === array('fid' => 'fid')) {
1880
                  $base_table = $table;
1881
                }
1882
              }
1883
            }
1884
            else {
1885
              // At least it's a fid. A table with a field called fid is very
1886
              // very likely to be a file_managed.fid in a file access query.
1887
              $fallback = $table;
1888
            }
1889
          }
1890
        }
1891
      }
1892
    }
1893
    // If there is nothing else, use the fallback.
1894
    if (!$base_table) {
1895
      if ($fallback) {
1896
        watchdog('security', 'Your file listing query is using @fallback as a base table in a query tagged for file access. This might not be secure and might not even work. Specify foreign keys in your schema to file_managed.fid ', array('@fallback' => $fallback), WATCHDOG_WARNING);
1897
        $base_table = $fallback;
1898
      }
1899
      else {
1900
        throw new Exception(t('Query tagged for file access but there is no fid. Add foreign keys to file_managed.fid in schema to fix.'));
1901
      }
1902
    }
1903
  }
1904

    
1905
  if ($type == 'entity') {
1906
    // The original query looked something like:
1907
    // @code
1908
    //  SELECT fid FROM sometable s
1909
    //  WHERE ($file_access_conditions)
1910
    // @endcode
1911
    //
1912
    // Our query will look like:
1913
    // @code
1914
    //  SELECT entity_type, entity_id
1915
    //  FROM field_data_something s
1916
    //  WHERE (entity_type = 'file' AND $file_access_conditions) OR (entity_type <> 'file')
1917
    // @endcode
1918
    //
1919
    // So instead of directly adding to the query object, we need to collect
1920
    // all of the file access conditions in a separate db_and() object and
1921
    // then add it to the query at the end.
1922
    $file_conditions = db_and();
1923
  }
1924
  foreach ($tables as $falias => $tableinfo) {
1925
    $table = $tableinfo['table'];
1926
    if (!($table instanceof SelectQueryInterface) && $table == $base_table) {
1927
      $subquery = db_select('file_managed', 'fm_access')->fields('fm_access', array('fid'));
1928
      $subquery_conditions = db_or();
1929

    
1930
      $wrappers = file_entity_get_public_and_private_stream_wrapper_names();
1931
      if (!empty($wrappers['public'])) {
1932
        if (user_access('view files', $account)) {
1933
          foreach (array_keys($wrappers['public']) as $wrapper) {
1934
            $subquery_conditions->condition('fm_access.uri', $wrapper . '%', 'LIKE');
1935
          }
1936
        }
1937
        elseif (user_access('view own files', $account)) {
1938
          foreach (array_keys($wrappers['public']) as $wrapper) {
1939
            $subquery_conditions->condition(db_and()
1940
              ->condition('fm_access.uri', $wrapper . '%', 'LIKE')
1941
              ->condition('fm_access.uid', $account->uid)
1942
            );
1943
          }
1944
        }
1945
      }
1946
      if (!empty($wrappers['private'])) {
1947
        if (user_access('view private files', $account)) {
1948
          foreach (array_keys($wrappers['private']) as $wrapper) {
1949
            $subquery_conditions->condition('fm_access.uri', $wrapper . '%', 'LIKE');
1950
          }
1951
        }
1952
        elseif (user_access('view own private files', $account)) {
1953
          foreach (array_keys($wrappers['private']) as $wrapper) {
1954
            $subquery_conditions->condition(db_and()
1955
              ->condition('fm_access.uri', $wrapper . '%', 'LIKE')
1956
              ->condition('fm_access.uid', $account->uid)
1957
            );
1958
          }
1959
        }
1960
      }
1961

    
1962
      if ($subquery_conditions->count()) {
1963
        $subquery->condition($subquery_conditions);
1964

    
1965
        $field = 'fid';
1966
        // Now handle entities.
1967
        if ($type == 'entity') {
1968
          // Set a common alias for entities.
1969
          $base_alias = $falias;
1970
          $field = 'entity_id';
1971
        }
1972
        $subquery->where("$falias.$field = fm_access.fid");
1973

    
1974
        // For an entity query, attach the subquery to entity conditions.
1975
        if ($type == 'entity') {
1976
          $file_conditions->exists($subquery);
1977
        }
1978
        // Otherwise attach it to the node query itself.
1979
        elseif ($table == 'file_managed') {
1980
          // Fix for https://drupal.org/node/2073085
1981
          $db_or = db_or();
1982
          $db_or->exists($subquery);
1983
          $db_or->isNull($falias . '.' . $field);
1984
          $query->condition($db_or);
1985
        }
1986
        else {
1987
          $query->exists($subquery);
1988
        }
1989
      }
1990
    }
1991
  }
1992

    
1993
  if ($type == 'entity' && $file_conditions->count()) {
1994
    // All the file access conditions are only for field values belonging to
1995
    // files.
1996
    $file_conditions->condition("$base_alias.entity_type", 'file');
1997
    $or = db_or();
1998
    $or->condition($file_conditions);
1999
    // If the field value belongs to a non-file entity type then this function
2000
    // does not do anything with it.
2001
    $or->condition("$base_alias.entity_type", 'file', '<>');
2002
    // Add the compiled set of rules to the query.
2003
    $query->condition($or);
2004
  }
2005
}
2006

    
2007
/**
2008
 * Implements hook_file_download().
2009
 */
2010
function file_entity_file_download($uri) {
2011
  // Load the file from the URI.
2012
  $file = file_uri_to_object($uri);
2013

    
2014
  // An existing file wasn't found, so we don't control access.
2015
  // E.g. image derivatives will fall here.
2016
  if (empty($file->fid)) {
2017
    return NULL;
2018
  }
2019

    
2020
  // Allow the user to download the file if they have appropriate permissions.
2021
  if (file_entity_access('view', $file)) {
2022
    return file_get_content_headers($file);
2023
  }
2024

    
2025
  return NULL;
2026
}
2027

    
2028
/**
2029
 * Helper function to generate standard file permission list for a given type.
2030
 *
2031
 * @param $type
2032
 *   The machine-readable name of the file type.
2033
 * @return array
2034
 *   An array of permission names and descriptions.
2035
 */
2036
function file_entity_list_permissions($type) {
2037
  $info = file_type_load($type);
2038

    
2039
  // Build standard list of file permissions for this type.
2040
  $permissions = array(
2041
    "edit own $type files" => array(
2042
      'title' => t('%type_name: Edit own files', array('%type_name' => $info->label)),
2043
    ),
2044
    "edit any $type files" => array(
2045
      'title' => t('%type_name: Edit any files', array('%type_name' => $info->label)),
2046
    ),
2047
    "delete own $type files" => array(
2048
      'title' => t('%type_name: Delete own files', array('%type_name' => $info->label)),
2049
    ),
2050
    "delete any $type files" => array(
2051
      'title' => t('%type_name: Delete any files', array('%type_name' => $info->label)),
2052
    ),
2053
    "download own $type files" => array(
2054
      'title' => t('%type_name: Download own files', array('%type_name' => $info->label)),
2055
    ),
2056
    "download any $type files" => array(
2057
      'title' => t('%type_name: Download any files', array('%type_name' => $info->label)),
2058
    ),
2059
  );
2060

    
2061
  return $permissions;
2062
}
2063

    
2064
/**
2065
 * Returns an array of file types that should be managed by permissions.
2066
 *
2067
 * By default, this will include all file types in the system. To exclude a
2068
 * specific file from getting permissions defined for it, set the
2069
 * file_entity_permissions_$type variable to 0. File entity does not provide an
2070
 * interface for doing so, however, contrib modules may exclude their own files
2071
 * in hook_install(). Alternatively, contrib modules may configure all file
2072
 * types at once, or decide to apply some other hook_file_entity_access()
2073
 * implementation to some or all file types.
2074
 *
2075
 * @return
2076
 *   An array of file types managed by this module.
2077
 */
2078
function file_entity_permissions_get_configured_types() {
2079

    
2080
  $configured_types = array();
2081

    
2082
  foreach (file_type_get_enabled_types() as $type => $info) {
2083
    if (variable_get('file_entity_permissions_' . $type, 1)) {
2084
      $configured_types[] = $type;
2085
    }
2086
  }
2087

    
2088
  return $configured_types;
2089
}
2090

    
2091
/**
2092
 * @} End of "defgroup file_entity_access".
2093
 *
2094
 * Implements hook_file_default_types().
2095
 */
2096
function file_entity_file_default_types() {
2097
  $types = array();
2098

    
2099
  // Image.
2100
  $types['image'] = (object) array(
2101
    'api_version' => 1,
2102
    'type' => 'image',
2103
    'label' => t('Image'),
2104
    'description' => t('An <em>Image</em> file is a still visual.'),
2105
    'mimetypes' => array(
2106
      'image/*',
2107
    ),
2108
  );
2109

    
2110
  // Video.
2111
  $types['video'] = (object) array(
2112
    'api_version' => 1,
2113
    'type' => 'video',
2114
    'label' => t('Video'),
2115
    'description' => t('A <em>Video</em> file is a moving visual recording.'),
2116
    'mimetypes' => array(
2117
      'video/*',
2118
    ),
2119
  );
2120

    
2121
  // Audio.
2122
  $types['audio'] = (object) array(
2123
    'api_version' => 1,
2124
    'type' => 'audio',
2125
    'label' => t('Audio'),
2126
    'description' => t('An <em>Audio</em> file is a sound recording.'),
2127
    'mimetypes' => array(
2128
      'audio/*',
2129
    ),
2130
  );
2131

    
2132
  // Document.
2133
  $types['document'] = (object) array(
2134
    'api_version' => 1,
2135
    'type' => 'document',
2136
    'label' => t('Document'),
2137
    'description' => t('A <em>Document</em> file is written information.'),
2138
    'mimetypes' => array(
2139
      'text/html',
2140
      'text/plain',
2141
      'application/acad',
2142
      'application/msword',
2143
      'application/vnd.ms-excel',
2144
      'application/pdf',
2145
      'application/vnd.ms-powerpoint',
2146
      'application/vnd.oasis.opendocument.text',
2147
      'application/vnd.oasis.opendocument.spreadsheet',
2148
      'application/vnd.oasis.opendocument.presentation',
2149
      'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
2150
      'application/vnd.openxmlformats-officedocument.presentationml.presentation',
2151
      'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
2152
      'application/zip',
2153
      'application/x-7z-compressed',
2154
      'application/x-tar',
2155
      'application/gzip',
2156
    ),
2157
  );
2158

    
2159
  return $types;
2160
}
2161

    
2162
/**
2163
 * Implements hook_file_operations().
2164
 */
2165
function file_entity_file_operations() {
2166
  $operations = array(
2167
    'permanent' => array(
2168
      'label' => t('Indicate that the selected files are permanent and should not be deleted'),
2169
      'callback' => 'file_entity_mass_update',
2170
      'callback arguments' => array('updates' => array('status' => FILE_STATUS_PERMANENT)),
2171
    ),
2172
    'temporary' => array(
2173
      'label' => t('Indicate that the selected files are temporary and should be removed during cron runs'),
2174
      'callback' => 'file_entity_mass_update',
2175
      'callback arguments' => array('updates' => array('status' => 0)),
2176
    ),
2177
    'delete' => array(
2178
      'label' => t('Delete selected files'),
2179
      'callback' => NULL,
2180
    ),
2181
  );
2182
  return $operations;
2183
}
2184

    
2185
/**
2186
 * Clear the field cache for any entities referencing a specific file.
2187
 *
2188
 * @param object $file
2189
 *   A file object.
2190
 */
2191
function file_entity_invalidate_field_caches($file) {
2192
  $entity_types = &drupal_static(__FUNCTION__);
2193

    
2194
  // Gather the list of entity types which support field caching.
2195
  if (!isset($entity_types)) {
2196
    $entity_types = array();
2197
    foreach (entity_get_info() as $entity_type => $entity_info) {
2198
      if (!empty($entity_info['fieldable']) && !empty($entity_info['field cache'])) {
2199
        $entity_types[] = $entity_type;
2200
      }
2201
    }
2202
  }
2203

    
2204
  // If no entity types support field caching, then there is no work to be done.
2205
  if (empty($entity_types)) {
2206
    return;
2207
  }
2208

    
2209
  $records = db_query("SELECT DISTINCT type, id FROM {file_usage} WHERE fid = :fid AND type IN (:types) AND id > 0", array(':fid' => $file->fid, ':types' => $entity_types))->fetchAll();
2210
  if (!empty($records)) {
2211
    $cids = array();
2212
    foreach ($records as $record) {
2213
      $cids[] = 'field:' . $record->type . ':' . $record->id;
2214
    }
2215
    cache_clear_all($cids, 'cache_field');
2216
  }
2217
}
2218

    
2219
/**
2220
 * Check if a file entity is considered local or not.
2221
 *
2222
 * @param object $file
2223
 *   A file entity object from file_load().
2224
 *
2225
 * @return
2226
 *   TRUE if the file is using a local stream wrapper, or FALSE otherwise.
2227
 */
2228
function file_entity_file_is_local($file) {
2229
  $scheme = file_uri_scheme($file->uri);
2230
  $wrappers = file_get_stream_wrappers(STREAM_WRAPPERS_LOCAL);
2231
  return !empty($wrappers[$scheme]) && empty($wrappers[$scheme]['remote']);
2232
}
2233

    
2234
/**
2235
 * Check if a file entity is considered writeable or not.
2236
 *
2237
 * @param object $file
2238
 *   A file entity object from file_load().
2239
 *
2240
 * @return
2241
 *   TRUE if the file is using a visible, readable and writeable stream wrapper,
2242
 *   or FALSE otherwise.
2243
 */
2244
function file_entity_file_is_writeable($file) {
2245
  $scheme = file_uri_scheme($file->uri);
2246
  $wrappers = file_get_stream_wrappers(STREAM_WRAPPERS_WRITE_VISIBLE);
2247
  return !empty($wrappers[$scheme]);
2248
}
2249

    
2250
/**
2251
 * Pre-render callback for adding validation descriptions to file upload fields.
2252
 */
2253
function file_entity_upload_validators_pre_render($element) {
2254
  if (!empty($element['#upload_validators'])) {
2255
    if (!isset($element['#description'])) {
2256
      $element['#description'] = '';
2257
    }
2258
    if ($element['#description'] !== FALSE) {
2259
      $element['#description'] = theme('file_upload_help', array('description' => $element['#description'], 'upload_validators' => $element['#upload_validators']));
2260
    }
2261
  }
2262
  return $element;
2263
}
2264

    
2265
/**
2266
 * @name pathauto_file Pathauto integration for the core file module.
2267
 * @{
2268
 */
2269

    
2270
/**
2271
 * Implements hook_file_insert() on behalf of pathauto.module.
2272
 */
2273
function pathauto_file_insert($file) {
2274
  pathauto_file_update_alias($file, 'insert');
2275
}
2276

    
2277
/**
2278
 * Implements hook_file_update() on behalf of pathauto.module.
2279
 */
2280
function pathauto_file_update($file) {
2281
  pathauto_file_update_alias($file, 'update');
2282
}
2283

    
2284
/**
2285
 * Implements hook_file_delete() on behalf of pathauto.module.
2286
 */
2287
function pathauto_file_delete($file) {
2288
  pathauto_entity_path_delete_all('file', $file, "file/{$file->fid}");
2289
}
2290

    
2291
/**
2292
 * Implements hook_form_FORM_ID_alter() on behalf of pathauto.module.
2293
 *
2294
 * Add the Pathauto settings to the file form.
2295
 */
2296
function pathauto_form_file_entity_edit_alter(&$form, &$form_state, $form_id) {
2297
  $file = $form_state['file'];
2298
  $langcode = pathauto_entity_language('file', $file);
2299
  pathauto_field_attach_form('file', $file, $form, $form_state, $langcode);
2300
}
2301

    
2302
/**
2303
 * Implements hook_file_operations() on behalf of pathauto.module.
2304
 */
2305
function pathauto_file_operations() {
2306
  $operations['pathauto_update_alias'] = array(
2307
    'label' => t('Update URL alias'),
2308
    'callback' => 'pathauto_file_update_alias_multiple',
2309
    'callback arguments' => array('bulkupdate', array('message' => TRUE)),
2310
  );
2311
  return $operations;
2312
}
2313

    
2314
/**
2315
 * Update the URL aliases for an individual file.
2316
 *
2317
 * @param $file
2318
 *   A file object.
2319
 * @param $op
2320
 *   Operation being performed on the file ('insert', 'update' or 'bulkupdate').
2321
 * @param $options
2322
 *   An optional array of additional options.
2323
 */
2324
function pathauto_file_update_alias(stdClass $file, $op, array $options = array()) {
2325
  // Skip processing if the user has disabled pathauto for the file.
2326
  if (isset($file->path['pathauto']) && empty($file->path['pathauto']) && empty($options['force'])) {
2327
    return;
2328
  }
2329

    
2330
  $options += array('language' => pathauto_entity_language('file', $file));
2331

    
2332
  // Skip processing if the file has no pattern.
2333
  if (!pathauto_pattern_load_by_entity('file', $file->type, $options['language'])) {
2334
    return;
2335
  }
2336

    
2337
  module_load_include('inc', 'pathauto');
2338
  $uri = entity_uri('file', $file);
2339
  pathauto_create_alias('file', $op, $uri['path'], array('file' => $file), $file->type, $options['language']);
2340
}
2341

    
2342
/**
2343
 * Update the URL aliases for multiple files.
2344
 *
2345
 * @param $fids
2346
 *   An array of file IDs.
2347
 * @param $op
2348
 *   Operation being performed on the files ('insert', 'update' or
2349
 *   'bulkupdate').
2350
 * @param $options
2351
 *   An optional array of additional options.
2352
 */
2353
function pathauto_file_update_alias_multiple(array $fids, $op, array $options = array()) {
2354
  $options += array('message' => FALSE);
2355

    
2356
  $files = file_load_multiple($fids);
2357
  foreach ($files as $file) {
2358
    pathauto_file_update_alias($file, $op, $options);
2359
  }
2360

    
2361
  if (!empty($options['message'])) {
2362
    drupal_set_message(format_plural(count($fids), 'Updated URL alias for 1 file.', 'Updated URL aliases for @count files.'));
2363
  }
2364
}
2365

    
2366
/**
2367
 * Update action wrapper for pathauto_file_update_alias().
2368
 */
2369
function pathauto_file_update_action($file, $context = array()) {
2370
  pathauto_file_update_alias($file, 'bulkupdate', array('message' => TRUE));
2371
}
2372

    
2373
/**
2374
 * @} End of "name pathauto_file".
2375
 */
2376

    
2377
/**
2378
 * Implements hook_form_FORM_ID_alter() for file_entity_edit() on behalf of path.module.
2379
 */
2380
function path_form_file_entity_edit_alter(&$form, $form_state) {
2381
  // Make sure this does not show up on the delete confirmation form.
2382
  if (empty($form_state['confirm_delete'])) {
2383
    $file = $form_state['file'];
2384
    $langcode = function_exists('entity_language') ? entity_language('file', $file) : NULL;
2385
    $langcode = !empty($langcode) ? $langcode : LANGUAGE_NONE;
2386
    $conditions = array('source' => 'file/' . $file->fid, 'language' => $langcode);
2387
    $path = (isset($file->fid) ? path_load($conditions) : array());
2388
    if ($path === FALSE) {
2389
      $path = array();
2390
    }
2391
    $path += array(
2392
      'pid' => NULL,
2393
      'source' => isset($file->fid) ? 'file/' . $file->fid : NULL,
2394
      'alias' => '',
2395
      'language' => $langcode,
2396
    );
2397
    $form['path'] = array(
2398
      '#type' => 'fieldset',
2399
      '#title' => t('URL path settings'),
2400
      '#collapsible' => TRUE,
2401
      '#collapsed' => empty($path['alias']),
2402
      '#group' => 'additional_settings',
2403
      '#attributes' => array(
2404
        'class' => array('path-form'),
2405
      ),
2406
      '#attached' => array(
2407
        'js' => array(drupal_get_path('module', 'path') . '/path.js'),
2408
      ),
2409
      '#access' => user_access('create url aliases') || user_access('administer url aliases'),
2410
      '#weight' => 30,
2411
      '#tree' => TRUE,
2412
      '#element_validate' => array('path_form_element_validate'),
2413
    );
2414
    $form['path']['alias'] = array(
2415
      '#type' => 'textfield',
2416
      '#title' => t('URL alias'),
2417
      '#default_value' => $path['alias'],
2418
      '#maxlength' => 255,
2419
      '#description' => t('Optionally specify an alternative URL by which this file can be accessed. For example, type "about" when writing an about page. Use a relative path and don\'t add a trailing slash or the URL alias won\'t work.'),
2420
    );
2421
    $form['path']['pid'] = array('#type' => 'value', '#value' => $path['pid']);
2422
    $form['path']['source'] = array('#type' => 'value', '#value' => $path['source']);
2423
    $form['path']['language'] = array('#type' => 'value', '#value' => $path['language']);
2424
  }
2425
}
2426

    
2427
/**
2428
 * Implements hook_file_insert() on behalf of path.module.
2429
 */
2430
function path_file_insert($file) {
2431
  if (isset($file->path)) {
2432
    $path = $file->path;
2433
    $path['alias'] = trim($path['alias']);
2434
    // Only save a non-empty alias.
2435
    if (!empty($path['alias'])) {
2436
      // Ensure fields for programmatic executions.
2437
      $path['source'] = 'file/' . $file->fid;
2438
      // Core does not provide a way to store the file language but contrib
2439
      // modules can do it so we need to take this into account.
2440
      $langcode = entity_language('file', $file);
2441
      $path['language'] = !empty($langcode) ? $langcode : LANGUAGE_NONE;
2442
      path_save($path);
2443
    }
2444
  }
2445
}
2446

    
2447
/**
2448
 * Implements hook_file_update() on behalf of path.module.
2449
 */
2450
function path_file_update($file) {
2451
  if (isset($file->path)) {
2452
    $path = $file->path;
2453
    $path['alias'] = trim($path['alias']);
2454
    // Delete old alias if user erased it.
2455
    if (!empty($path['fid']) && empty($path['alias'])) {
2456
      path_delete($path['fid']);
2457
    }
2458
    // Only save a non-empty alias.
2459
    if (!empty($path['alias'])) {
2460
      // Ensure fields for programmatic executions.
2461
      $path['source'] = 'file/' . $file->fid;
2462
      // Core does not provide a way to store the file language but contrib
2463
      // modules can do it so we need to take this into account.
2464
      $langcode = entity_language('file', $file);
2465
      $path['language'] = !empty($langcode) ? $langcode : LANGUAGE_NONE;
2466
      path_save($path);
2467
    }
2468
  }
2469
}
2470

    
2471
/**
2472
 * Implements hook_file_delete() on behalf of path.module.
2473
 */
2474
function path_file_delete($file) {
2475
  // Delete all aliases associated with this file.
2476
  path_delete(array('source' => 'file/' . $file->fid));
2477
}
2478

    
2479
/**
2480
 * Checks if pattern(s) match mimetype(s).
2481
 */
2482
function file_entity_match_mimetypes($needle, $haystack) {
2483
  $needle = is_array($needle) ? $needle : array($needle);
2484
  $haystack = is_array($haystack) ? $haystack : array($haystack);
2485

    
2486
  foreach ($haystack as $mimetype) {
2487
    foreach ($needle as $search) {
2488
      if (file_entity_fnmatch($search, $mimetype) || file_entity_fnmatch($mimetype, $search)) {
2489
        return TRUE;
2490
      }
2491
    }
2492
  }
2493

    
2494
  return FALSE;
2495
}
2496

    
2497
/**
2498
 * A wrapper function for the PHP function fnmatch().
2499
 *
2500
 * We include this, because Windows servers do not implement fnmatch() until
2501
 * PHP Version 5.3. See: http://php.net/manual/en/function.fnmatch.php
2502
 */
2503
function file_entity_fnmatch($pattern, $string) {
2504
  if (!function_exists('fnmatch')) {
2505
    return preg_match("#^" . strtr(preg_quote($pattern, '#'), array('\*' => '.*', '\?' => '.', '\[' => '[', '\]' => ']')) . "$#", $string);
2506
  }
2507
  return fnmatch($pattern, $string);
2508
}
2509

    
2510
/**
2511
 * Return an URI for a file download.
2512
 */
2513
function file_entity_download_uri($file) {
2514
  $uri = array('path' => "file/{$file->fid}/download", 'options' => array());
2515
  if (!variable_get('file_entity_allow_insecure_download', FALSE)) {
2516
    $uri['options']['query']['token'] = file_entity_get_download_token($file);
2517
  }
2518
  return $uri;
2519
}
2520

    
2521
function file_entity_file_get_mimetype_type($file) {
2522
  if (is_array($file)) {
2523
    $file = (object) $file;
2524
  }
2525
  list($type, $subtype) = explode('/', $file->filemime, 2);
2526
  return $type;
2527
}
2528

    
2529
/**
2530
 * Implements hook_admin_menu_map().
2531
 */
2532
function file_entity_admin_menu_map() {
2533
  if (!user_access('administer file types')) {
2534
    return;
2535
  }
2536
  $map['admin/structure/file-types/manage/%file_type'] = array(
2537
    'parent' => 'admin/structure/file-types',
2538
    'arguments' => array(
2539
      array('%file_type' => array_keys(file_entity_type_get_names())),
2540
    ),
2541
  );
2542
  return $map;
2543
}
2544

    
2545
/*
2546
 * Generates a token to protect a file download URL.
2547
 *
2548
 * This prevents unauthorized crawling of all file download URLs since the
2549
 * {file_managed}.fid column is an auto-incrementing serial field and is easy
2550
 * to guess or attempt many at once. This can be costly both in CPU time
2551
 * and bandwidth.
2552
 *
2553
 * @see image_style_path_token()
2554
 *
2555
 * @param object $file
2556
 *   A file entity object.
2557
 *
2558
 * @return string
2559
 *   An eight-character token which can be used to protect file downloads
2560
 *   against denial-of-service attacks.
2561
 */
2562
function file_entity_get_download_token($file) {
2563
  // Return the first eight characters.
2564
  return substr(drupal_hmac_base64("file/$file->fid/download:" . $file->uri, drupal_get_private_key() . drupal_get_hash_salt()), 0, 8);
2565
}
2566

    
2567
/**
2568
 * Find all fields that are of a certain field type.
2569
 *
2570
 * @param string $field_type
2571
 *   A field type.
2572
 *
2573
 * @return array
2574
 *   An array of field names that match the type $field_type.
2575
 */
2576
function _file_entity_get_fields_by_type($field_type) {
2577
  $return = array();
2578
  if (function_exists('field_info_field_map')) {
2579
    foreach (field_info_field_map() as $field_name => $field) {
2580
      if ($field['type'] == $field_type) {
2581
        $return[$field_name] = $field_name;
2582
      }
2583
    }
2584
  }
2585
  else {
2586
    foreach (field_info_fields() as $field_name => $field) {
2587
      if ($field['type'] == $field_type) {
2588
        $return[$field_name] = $field_name;
2589
      }
2590
    }
2591
  }
2592
  return $return;
2593
}
2594

    
2595
/**
2596
 * Implements hook_field_attach_load().
2597
 */
2598
function file_entity_field_attach_load($entity_type, $entities, $age, $options) {
2599
  // Loop over all the entities looking for entities with attached images.
2600
  foreach ($entities as $entity) {
2601
    list(, , $bundle) = entity_extract_ids($entity_type, $entity);
2602
    // Examine every image field instance attached to this entity's bundle.
2603
    $instances = array_intersect_key(field_info_instances($entity_type, $bundle), _file_entity_get_fields_by_type('image'));
2604
    foreach ($instances as $field_name => $instance) {
2605
      if (!empty($entity->{$field_name})) {
2606
        foreach ($entity->{$field_name} as $langcode => $items) {
2607
          foreach ($items as $delta => $item) {
2608
            // If alt and title text is not specified, fall back to alt and
2609
            // title text on the file.
2610
            if (!empty($item['fid']) && (empty($item['alt']) || empty($item['title']))) {
2611
              $file = file_load($item['fid']);
2612
              foreach (array('alt', 'title') as $key) {
2613
                if (empty($item[$key]) && !empty($file->{$key})) {
2614
                  $entity->{$field_name}[$langcode][$delta][$key] = $file->{$key};
2615
                }
2616
              }
2617
            }
2618
          }
2619
        }
2620
      }
2621
    }
2622
  }
2623
}
2624

    
2625
function file_entity_get_public_and_private_stream_wrapper_names($flag = STREAM_WRAPPERS_VISIBLE) {
2626
  $wrappers = array();
2627
  foreach (file_get_stream_wrappers($flag) as $key => $wrapper) {
2628
    if (empty($wrapper['private'])) {
2629
      $wrappers['public'][$key] = $wrapper['name'];
2630
    }
2631
    else {
2632
      $wrappers['private'][$key] = $wrapper['name'];
2633
    }
2634
  }
2635
  return $wrappers;
2636
}
2637

    
2638
/**
2639
 * Implements hook_features_pipe_alter() for the file type component.
2640
 */
2641
function file_entity_features_pipe_file_type_alter(&$pipe, $data, $export) {
2642
  foreach ($data as $file_type) {
2643
    $pipe['variable'][] = "pathauto_file_{$file_type}_pattern";
2644
  }
2645
}
2646

    
2647
/**
2648
 * Implements hook_FORM_ID_alter().
2649
 */
2650
function file_entity_form_system_performance_settings_alter(&$form, &$form_state) {
2651
  $form['bandwidth_optimization']['file_entity_total_count_optimization'] = array(
2652
    '#type' => 'checkbox',
2653
    '#title' => t('Optimize the calculation of the total usage count of files in the files overview.'),
2654
    '#default_value' => variable_get('file_entity_total_count_optimization', FALSE),
2655
    '#description' => t('Recommended if the files admin page loads too slowly due to a high number of files.'),
2656
  );
2657
}