files data processor

New in version 12.1

This data processor \TYPO3\CMS\Frontend\DataProcessing\FilesProcessor , alias files, can be used for processing file information:

  • relations to file records (sys_file_reference)
  • fetch files records by their uids in table (sys_file)
  • all files from a certain folder
  • all files from a collection

A FLUIDTEMPLATE can then iterate over processed data automatically.

Table of contents

Options:

Name Type Default
if
 if condition ''
references
 string (comma-separated integers) / stdWrap ''
references.fieldName
 string / stdWrap ''
references.table
 string / stdWrap ''
files
 string (comma-separated integers) / stdWrap ''
collections
 string (comma-separated integers) / stdWrap ''
folders
 string (comma-separated folders), stdWrap ""
folders.recursive
 string / stdWrap ""
sorting
 string / stdWrap ""
sorting.direction
 string / stdWrap "ascending"
as
 string / stdWrap "files"

if

if
Type
if condition
Required
false
Default
''

Only, if the condition is met the data processor is executed.

references

references
Type
string (comma-separated integers) / stdWrap
Required
false
Default
''
Example
'1,303,42'

If this option contains a comma-separated list of integers, these are treated as uids of file references (sys_file_reference).

The corresponding file records are added to the output array.

stdWrap properties can also be used, see Example 2: use stdWrap property on references.

references.fieldName

references.fieldName
Type
string / stdWrap
Required
false
Default
''
Example
'media'

If both references.fieldName and references.table are set, the file records are fetched from the referenced table and field, for example the media field of a tt_content record.

references.table

references.table
Type
string / stdWrap
Required
false
Default
''
Example
'tt_content'

If references should be interpreted as TypoScript select function, references.fieldName must be set to the desired field name of the table to be queried.

files

files
Type
string (comma-separated integers) / stdWrap
Required
false
Default
''
Example
'1,303,42'

If this option contains a comma-separated list of integers, these are treated as uids of files (sys_file).

collections

collections
Type
string (comma-separated integers) / stdWrap
Required
false
Default
''
Example
'1,303,42'

If this option contains a comma-separated list of integers, these are treated as uids of collections. The file records in each collection are then being added to the output array.

folders

folders
Type
string (comma-separated folders), stdWrap
Required
false
Default
""
Example
"23:/other/folder/"

Fetches all files from the referenced folders. The following syntax is possible:

t3://folder?storage=2&identifier=/my/folder/
Folder /my/folder/ from storage with uid 2
23:/other/folder/
Folder /other/folder/ from storage with uid 23
/folderInMyFileadmin/something/:
Folder /folderInMyFileadmin/something/ from the default storage 0 (fileadmin)

folders.recursive

folders.recursive
Type
string / stdWrap
Required
false
Default
""
Example
"1"

If set to a non-empty value file, records will be added from folders recursively.

sorting

sorting
Type
string / stdWrap
Required
false
Default
""
Example
"filesize"

The property of the file records by which they should be sorted. For example, filesize or title.

sorting.direction

sorting.direction
Type
string / stdWrap
Required
false
Default
"ascending"
Example
"descending"

The sorting direction (ascending or descending).

as

as
Type
string / stdWrap
Required
false
Default
"files"

The variable name to be used in the Fluid template.

Example 1: Render the images stored in field image

Please see also About the examples.

TypoScript

Using the FilesProcessor the following scenario is possible:

EXT:examples/Configuration/TypoScript/DataProcessors/Processors/FilesProcessor.typoscript 
tt_content {
    examples_dataprocfiles =< lib.contentElement
    examples_dataprocfiles {
        templateName = DataProcFiles
        # Before TYPO3 v12.1 you have to specify the fully-qualified class name of the processor
        # dataProcessing.10 = TYPO3\CMS\Frontend\DataProcessing\FilesProcessor
        # Since TYPO3 v12.1 one can also use the available alias
        dataProcessing.10 = files
        dataProcessing.10 {
            as = images
            references.fieldName = image
            references.table = tt_content
            sorting = title
            sorting.direction = descending
        }
    }
}
Copied!
The Fluid template

Then iterate over the files in the Fluid template:

EXT:examples/Resources/Private/Templates/ContentElements/DataProcFiles.html 
<html data-namespace-typo3-fluid="true" xmlns:f="http://typo3.org/ns/TYPO3/CMS/Fluid/ViewHelpers">
   <h2>Data in variable images</h2>
   <f:debug inline="true">{images}</f:debug>
   <h2>Data in variable images</h2>

   <div class="row">
      <div class="row">
         <f:for each="{images}" as="image">
            <div class="col-12 col-md-3">
               <div class="card">
                  <f:image image="{image}" class="card-img-top" height="250"/>
                  <div class="card-body">
                     <h5 class="card-title">{image.title}</h5>
                     <div class="card-text">{image.description}</div>
                  </div>
               </div>
            </div>
         </f:for>
      </div>
   </div>
</html>
Copied!
Output

The array images contains the data of the files now:

files dump and output

Example 2: use stdWrap property on references

The following example implements a slide functionality on root line for file resources:

EXT:site_package/Configuration/TypoScript/setup.typoscript 
page.10.dataProcessing {
    10 = TYPO3\CMS\Frontend\DataProcessing\FilesProcessor
    10 {
        references.data = levelmedia: -1, slide
        as = myfiles
    }
}
Copied!

The FilesProcessor can slide up the root line to collect images for Fluid templates. One usual feature is to take images attached to pages and use them on the page tree as header images in the frontend.

Example 3: files from a FlexForm

If the files are stored in a FlexForm, the entry in the table sys_file_reference uses the name of the main table, for example tt_content and the FlexForm key as fieldname.

Therefore, you can do the following:

EXT:site_package/Configuration/TypoScript/setup.typoscript 
page.10.dataProcessing {
    10 = TYPO3\CMS\Frontend\DataProcessing\FilesProcessor
    10 {
        references.table = tt_content
        references.field = settings.myImage
        as = myImageFromFlexForm
    }
}
Copied!

This assumes that the image was stored in a FlexForm in the table tt_content like this:

EXT:site_package/Configuration/FlexForm/MyFlexForm.xml 
<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<T3DataStructure>
    <sheets>
        <main>
            <ROOT type="array">
                <TCEforms><sheetTitle>Something</sheetTitle></TCEforms>
                <type>array</type>
                <el type="array">
                    <settings.myImage>
                        <TCEforms>
                            <label>My Images</label>
                            <config>
                                <type>file</type>
                                <maxitems>6</maxitems>
                                <allowed>common-image-types</allowed>
                            </config>
                        </TCEforms>
                    </settings.myImage>
                </el>
            </ROOT>
        </main>
    </sheets>
</T3DataStructure>
Copied!

Three images in the same content element (uid 15) having the FlexForm above would look like this in the the database table sys_file_reference:

uid pid uid_local uid_foreign tablenames fieldnames ...
42 120 12 15 tt_content settings.myImage ...
43 120 25 15 tt_content settings.myImage ...
44 120 128 15 tt_content settings.myImage ...