/**
* Fetches records from the database as an array
*
* @param ContentObjectRenderer $cObj The data of the content element or page
* @param array $contentObjectConfiguration The configuration of Content Object
* @param array $processorConfiguration The configuration of this processor
* @param array $processedData Key/value store of processed data (e.g. to be passed to a Fluid View)
*
* @return array the processed data as key/value store
*/
public function process(ContentObjectRenderer $cObj, array $contentObjectConfiguration, array $processorConfiguration, array $processedData)
{
if (isset($processorConfiguration['if.']) && !$cObj->checkIf($processorConfiguration['if.'])) {
return $processedData;
}
// the table to query, if none given, exit
$tableName = $cObj->stdWrapValue('table', $processorConfiguration);
if (empty($tableName)) {
return $processedData;
}
if (isset($processorConfiguration['table.'])) {
unset($processorConfiguration['table.']);
}
if (isset($processorConfiguration['table'])) {
unset($processorConfiguration['table']);
}
// The variable to be used within the result
$targetVariableName = $cObj->stdWrapValue('as', $processorConfiguration, 'records');
// Execute a SQL statement to fetch the records
$records = $cObj->getRecords($tableName, $processorConfiguration);
$processedRecordVariables = array();
foreach ($records as $key => $record) {
/** @var ContentObjectRenderer $recordContentObjectRenderer */
$recordContentObjectRenderer = GeneralUtility::makeInstance('TYPO3\\CMS\\Frontend\\ContentObject\\ContentObjectRenderer');
$recordContentObjectRenderer->start($record, $tableName);
$processedRecordVariables[$key] = array('data' => $record);
$processedRecordVariables[$key] = $this->contentDataProcessor->process($recordContentObjectRenderer, $processorConfiguration, $processedRecordVariables[$key]);
}
$processedData[$targetVariableName] = $processedRecordVariables;
return $processedData;
}
/**
* Generate variable Get string from classMappings array with the same key as the "layout" in the content
*
* @param ContentObjectRenderer $cObj The data of the content element or page
* @param array $contentObjectConfiguration The configuration of Content Object
* @param array $processorConfiguration The configuration of this processor
* @param array $processedData Key/value store of processed data (e.g. to be passed to a Fluid View)
* @return array the processed data as key/value store
*/
public function process(ContentObjectRenderer $cObj, array $contentObjectConfiguration, array $processorConfiguration, array $processedData)
{
if (isset($processorConfiguration['if.']) && !$cObj->checkIf($processorConfiguration['if.'])) {
return $processedData;
}
// set targetvariable, default "layoutClass"
$targetVariableName = $cObj->stdWrapValue('as', $processorConfiguration, 'layoutClass');
$processedData[$targetVariableName] = '';
// set fieldname, default "layout"
$fieldName = $cObj->stdWrapValue('fieldName', $processorConfiguration, 'layout');
if (isset($cObj->data[$fieldName]) && is_array($processorConfiguration['classMappings.'])) {
$layoutClassMappings = GeneralUtility::removeDotsFromTS($processorConfiguration['classMappings.']);
$processedData[$targetVariableName] = $layoutClassMappings[$cObj->data[$fieldName]];
}
// if targetvariable is settings, try to merge it with contentObjectConfiguration['settings.']
if ($targetVariableName == 'settings') {
if (is_array($contentObjectConfiguration['settings.'])) {
$convertedConf = GeneralUtility::removeDotsFromTS($contentObjectConfiguration['settings.']);
foreach ($convertedConf as $key => $value) {
if (!isset($processedData[$targetVariableName][$key]) || $processedData[$targetVariableName][$key] == false) {
$processedData[$targetVariableName][$key] = $value;
}
}
}
}
return $processedData;
}
/**
* Process flexform field data to an array
*
* @param ContentObjectRenderer $cObj The data of the content element or page
* @param array $contentObjectConfiguration The configuration of Content Object
* @param array $processorConfiguration The configuration of this processor
* @param array $processedData Key/value store of processed data (e.g. to be passed to a Fluid View)
* @return array the processed data as key/value store
*/
public function process(ContentObjectRenderer $cObj, array $contentObjectConfiguration, array $processorConfiguration, array $processedData)
{
if (isset($processorConfiguration['if.']) && !$cObj->checkIf($processorConfiguration['if.'])) {
return $processedData;
}
// set targetvariable, default "flexform"
$targetVariableName = $cObj->stdWrapValue('as', $processorConfiguration, 'flexform');
// set fieldname, default "pi_flexform"
$fieldName = $cObj->stdWrapValue('fieldName', $processorConfiguration, 'pi_flexform');
// parse flexform
$flexformService = GeneralUtility::makeInstance('TYPO3\\CMS\\Extbase\\Service\\FlexFormService');
$processedData[$targetVariableName] = $flexformService->convertFlexFormContentToArray($cObj->data[$fieldName]);
// if targetvariable is settings, try to merge it with contentObjectConfiguration['settings.']
if ($targetVariableName == 'settings') {
if (is_array($contentObjectConfiguration['settings.'])) {
$convertedConf = GeneralUtility::removeDotsFromTS($contentObjectConfiguration['settings.']);
foreach ($convertedConf as $key => $value) {
if (!isset($processedData[$targetVariableName][$key]) || $processedData[$targetVariableName][$key] == false) {
$processedData[$targetVariableName][$key] = $value;
}
}
}
}
return $processedData;
}
/**
* Process data of a record to resolve File objects to the view
*
* @param ContentObjectRenderer $cObj The data of the content element or page
* @param array $contentObjectConfiguration The configuration of Content Object
* @param array $processorConfiguration The configuration of this processor
* @param array $processedData Key/value store of processed data (e.g. to be passed to a Fluid View)
* @return array the processed data as key/value store
*/
public function process(ContentObjectRenderer $cObj, array $contentObjectConfiguration, array $processorConfiguration, array $processedData)
{
if (isset($processorConfiguration['if.']) && !$cObj->checkIf($processorConfiguration['if.'])) {
return $processedData;
}
// gather data
/** @var FileCollector $fileCollector */
$fileCollector = GeneralUtility::makeInstance(FileCollector::class);
$settings = $contentObjectConfiguration['settings.']['display_mode.'];
// references / relations
if (!empty($processorConfiguration['references.'])) {
$referenceConfiguration = $processorConfiguration['references.'];
$relationField = $cObj->stdWrapValue('fieldName', $referenceConfiguration);
// If no reference fieldName is set, there's nothing to do
if (!empty($relationField)) {
// Fetch the references of the default element
$relationTable = $cObj->stdWrapValue('table', $referenceConfiguration, $cObj->getCurrentTable());
if (!empty($relationTable)) {
$fileCollector->addFilesFromRelation($relationTable, $relationField, $cObj->data);
}
}
}
// Get files from database-record
$files = $fileCollector->getFiles();
if (count($files) > 0) {
// Use ImageService for further processing
$imageService = self::getImageService();
foreach ($files as $file) {
$displayMode = $file->getReferenceProperty('display_mode');
$image = $imageService->getImage(null, $file, true);
$processingInstructions = ['crop' => $image->getProperty('crop')];
$maxWidth = intval($contentObjectConfiguration['settings.']['display_mode_maxWidth.'][$displayMode]);
if ($maxWidth > 0) {
$processingInstructions['maxWidth'] = $maxWidth;
}
$processedImage = $imageService->applyProcessingInstructions($image, $processingInstructions);
$styleAttribute = 'background-image:url(\'' . $imageService->getImageUri($processedImage) . '\');';
switch ($displayMode) {
case '1':
$targetVariableName = 'layoutMedia';
break;
default:
$targetVariableName = 'backgroundMedia';
break;
}
$processedData[$targetVariableName]['fileReference'] = $file;
$processedData[$targetVariableName]['class'] = $settings[$displayMode];
$processedData[$targetVariableName]['style'] = $styleAttribute;
}
}
//\TYPO3\CMS\Extbase\Utility\DebuggerUtility::var_dump($files, '$files');
return $processedData;
}
/**
* Process data of a record to resolve File objects to the view
*
* @param ContentObjectRenderer $cObj The data of the content element or page
* @param array $contentObjectConfiguration The configuration of Content Object
* @param array $processorConfiguration The configuration of this processor
* @param array $processedData Key/value store of processed data (e.g. to be passed to a Fluid View)
* @return array the processed data as key/value store
*/
public function process(ContentObjectRenderer $cObj, array $contentObjectConfiguration, array $processorConfiguration, array $processedData)
{
if (isset($processorConfiguration['if.']) && !$cObj->checkIf($processorConfiguration['if.'])) {
return $processedData;
}
// gather data
/** @var FileCollector $fileCollector */
$fileCollector = GeneralUtility::makeInstance(FileCollector::class);
// references / relations
if (!empty($processorConfiguration['references.'])) {
$referenceConfiguration = $processorConfiguration['references.'];
$relationField = $cObj->stdWrapValue('fieldName', $referenceConfiguration);
// If no reference fieldName is set, there's nothing to do
if (!empty($relationField)) {
// Fetch the references of the default element
$relationTable = $cObj->stdWrapValue('table', $referenceConfiguration, $cObj->getCurrentTable());
if (!empty($relationTable)) {
$fileCollector->addFilesFromRelation($relationTable, $relationField, $cObj->data);
}
}
}
// files
$files = $cObj->stdWrapValue('files', $processorConfiguration);
if ($files) {
$files = GeneralUtility::intExplode(',', $files, TRUE);
$fileCollector->addFiles($files);
}
// collections
$collections = $cObj->stdWrapValue('collections', $processorConfiguration);
if (!empty($collections)) {
$collections = GeneralUtility::trimExplode(',', $collections, TRUE);
$fileCollector->addFilesFromFileCollections($collections);
}
// folders
$folders = $cObj->stdWrapValue('folders', $processorConfiguration);
if (!empty($folders)) {
$folders = GeneralUtility::trimExplode(',', $folders, TRUE);
$fileCollector->addFilesFromFolders($folders);
}
// make sure to sort the files
$sortingProperty = $cObj->stdWrapValue('sorting', $processorConfiguration);
if ($sortingProperty) {
$sortingDirection = $cObj->stdWrapValue('direction', isset($processorConfiguration['sorting.']) ? $processorConfiguration['sorting.'] : array(), 'ascending');
$fileCollector->sort($sortingProperty, $sortingDirection);
}
// set the files into a variable, default "files"
$targetVariableName = $cObj->stdWrapValue('as', $processorConfiguration, 'files');
$processedData[$targetVariableName] = $fileCollector->getFiles();
return $processedData;
}
/**
* Process field data to split in an array
*
* @param ContentObjectRenderer $cObj The data of the content element or page
* @param array $contentObjectConfiguration The configuration of Content Object
* @param array $processorConfiguration The configuration of this processor
* @param array $processedData Key/value store of processed data (e.g. to be passed to a Fluid View)
* @return array the processed data as key/value store
*/
public function process(ContentObjectRenderer $cObj, array $contentObjectConfiguration, array $processorConfiguration, array $processedData)
{
if (isset($processorConfiguration['if.']) && !$cObj->checkIf($processorConfiguration['if.'])) {
return $processedData;
}
// The field name to process
$fieldName = $cObj->stdWrapValue('fieldName', $processorConfiguration);
if (empty($fieldName)) {
return $processedData;
}
$originalValue = $cObj->data[$fieldName];
// Set the target variable
$targetVariableName = $cObj->stdWrapValue('as', $processorConfiguration, $fieldName);
// Set the delimiter which is "LF" by default
$delimiter = $cObj->stdWrapValue('delimiter', $processorConfiguration, LF);
// Filter integers
$filterIntegers = (bool) $cObj->stdWrapValue('filterIntegers', $processorConfiguration, false);
// Filter unique
$filterUnique = (bool) $cObj->stdWrapValue('filterUnique', $processorConfiguration, false);
// Remove empty entries
$removeEmptyEntries = (bool) $cObj->stdWrapValue('removeEmptyEntries', $processorConfiguration, false);
if ($filterIntegers === true) {
$processedData[$targetVariableName] = GeneralUtility::intExplode($delimiter, $originalValue, $removeEmptyEntries);
} else {
$processedData[$targetVariableName] = GeneralUtility::trimExplode($delimiter, $originalValue, $removeEmptyEntries);
}
if ($filterUnique === true) {
$processedData[$targetVariableName] = array_unique($processedData[$targetVariableName]);
}
return $processedData;
}
/**
* Process CSV field data to split into a multi dimensional array
*
* @param ContentObjectRenderer $cObj The data of the content element or page
* @param array $contentObjectConfiguration The configuration of Content Object
* @param array $processorConfiguration The configuration of this processor
* @param array $processedData Key/value store of processed data (e.g. to be passed to a Fluid View)
* @return array the processed data as key/value store
*/
public function process(ContentObjectRenderer $cObj, array $contentObjectConfiguration, array $processorConfiguration, array $processedData)
{
if (isset($processorConfiguration['if.']) && !$cObj->checkIf($processorConfiguration['if.'])) {
return $processedData;
}
// The field name to process
$fieldName = $cObj->stdWrapValue('fieldName', $processorConfiguration);
if (empty($fieldName)) {
return $processedData;
}
$originalValue = $cObj->data[$fieldName];
// Set the target variable
$targetVariableName = $cObj->stdWrapValue('as', $processorConfiguration, $fieldName);
// Set the maximum amount of columns
$maximumColumns = $cObj->stdWrapValue('maximumColumns', $processorConfiguration, 0);
// Set the field delimiter which is "," by default
$fieldDelimiter = $cObj->stdWrapValue('fieldDelimiter', $processorConfiguration, ',');
// Set the field enclosure which is " by default
$fieldEnclosure = $cObj->stdWrapValue('fieldEnclosure', $processorConfiguration, '"');
$processedData[$targetVariableName] = CsvUtility::csvToArray($originalValue, $fieldDelimiter, $fieldEnclosure, (int) $maximumColumns);
return $processedData;
}
/**
* Process flexform field data to an array
*
* @param ContentObjectRenderer $cObj The data of the content element or page
* @param array $contentObjectConfiguration The configuration of Content Object
* @param array $processorConfiguration The configuration of this processor
* @param array $processedData Key/value store of processed data (e.g. to be passed to a Fluid View)
* @return array the processed data as key/value store
*/
public function process(ContentObjectRenderer $cObj, array $contentObjectConfiguration, array $processorConfiguration, array $processedData)
{
if (isset($processorConfiguration['if.']) && !$cObj->checkIf($processorConfiguration['if.'])) {
return $processedData;
}
$this->cObj = $cObj;
$languages = array();
// set targetvariable, default "flexform"
$targetVariableName = $cObj->stdWrapValue('as', $processorConfiguration, 'languages');
$availableLanguages = array_unique(GeneralUtility::trimExplode(',', '0,' . $processorConfiguration['availableLanguages'], TRUE));
$currentLanguageUid = (int) $processorConfiguration['currentLanguageUid'];
$defaultLanguageIsoCode = $processorConfiguration['defaultLanguageIsoCode'] ? $processorConfiguration['defaultLanguageIsoCode'] : 'en';
$defaultLanguageLabel = $processorConfiguration['defaultLanguageLabel'] ? $processorConfiguration['defaultLanguageLabel'] : 'English';
$defaultLanguageFlag = $processorConfiguration['defaultLanguageFlag'] ? $processorConfiguration['defaultLanguageFlag'] : 'gb';
$flagIconPath = $processorConfiguration['flagIconPath'];
$flagIconFileExtension = $processorConfiguration['flagIconFileExtension'];
if (!empty($availableLanguages)) {
foreach ($availableLanguages as $languageUid) {
$languageIsocode = '';
$class = '';
$label = '';
$flag = '';
$hasTranslation = FALSE;
if ((int) $languageUid === 0) {
$languageIsocode = $defaultLanguageIsoCode;
$flag = $defaultLanguageFlag;
$label = $defaultLanguageLabel;
$hasTranslation = TRUE;
} elseif ($sysLanguage = $this->getSysLanguage($languageUid)) {
$languageIsocode = $sysLanguage['language_isocode'];
$flag = $sysLanguage['flag'];
$label = $sysLanguage['title'];
$hasTranslation = $this->hasTranslation($GLOBALS['TSFE']->id, $languageUid);
}
$languages[] = array('L' => $languageUid, 'languageIsocode' => $languageIsocode, 'label' => $label, 'flag' => $flag, 'hasTranslation' => $hasTranslation, 'active' => (int) $currentLanguageUid === (int) $languageUid);
}
$processedData[$targetVariableName] = $languages;
}
// if targetvariable is settings, try to merge it with contentObjectConfiguration['settings.']
if ($targetVariableName == 'settings') {
if (is_array($contentObjectConfiguration['settings.'])) {
$convertedConf = GeneralUtility::removeDotsFromTS($contentObjectConfiguration['settings.']);
foreach ($convertedConf as $key => $value) {
if (!isset($processedData[$targetVariableName][$key]) || $processedData[$targetVariableName][$key] == false) {
$processedData[$targetVariableName][$key] = $value;
}
}
}
}
return $processedData;
}
/**
* Preprocess fields from database-record for use in fluid-templates
*
* @param ContentObjectRenderer $cObj The data of the content element or page
* @param array $contentObjectConfiguration The configuration of Content Object
* @param array $processorConfiguration The configuration of this processor
* @param array $processedData Key/value store of processed data (e.g. to be passed to a Fluid View)
* @return array the processed data as key/value store
*/
public function process(ContentObjectRenderer $cObj, array $contentObjectConfiguration, array $processorConfiguration, array $processedData)
{
if (isset($processorConfiguration['if.']) && !$cObj->checkIf($processorConfiguration['if.'])) {
return $processedData;
}
// The field name to process
$fieldName = $cObj->stdWrapValue('fieldName', $processorConfiguration);
if (empty($fieldName)) {
return $processedData;
}
// Set the target variable
$defaultTargetName = GeneralUtility::underscoredToLowerCamelCase($fieldName);
$targetVariableName = $cObj->stdWrapValue('as', $processorConfiguration, $defaultTargetName);
// Let's see if we got a parentField from which the values should be retrieved
$parentField = $cObj->stdWrapValue('parentField', $processorConfiguration);
// Get settings from TypoScript
if (!empty($parentField)) {
$settings = $contentObjectConfiguration['settings.'][$fieldName . '.'][$cObj->data[$parentField] . '.'];
} else {
$settings = $contentObjectConfiguration['settings.'][$fieldName . '.'];
}
// Get value database
$fieldValue = $cObj->data[$fieldName];
// Fill output with value from TypoScript
if (!empty($fieldValue)) {
// Use the value defined in database
$output = $settings[$fieldValue];
} else {
if ($settings['default'] !== '' && $settings[$settings['default']] !== '') {
// Use default value (if set)
$output = $settings[$settings['default']];
} else {
$output = '';
}
}
$processedData[$targetVariableName] = $output;
return $processedData;
}
/**
* @param ContentObjectRenderer $cObj The data of the content element or page
* @param array $contentObjectConfiguration The configuration of Content Object
* @param array $processorConfiguration The configuration of this processor
* @param array $processedData Key/value store of processed data (e.g. to be passed to a Fluid View)
* @return array the processed data as key/value store
*/
public function process(ContentObjectRenderer $cObj, array $contentObjectConfiguration, array $processorConfiguration, array $processedData)
{
// The field name to process
$fieldName = $cObj->stdWrapValue('fieldName', $processorConfiguration);
if (empty($fieldName) && !$processedData['data']['pi_flexform']) {
return $processedData;
} else {
$fieldName = 'pi_flexform';
}
// Process Flexform
$originalValue = $processedData['data'][$fieldName];
if (!is_string($originalValue)) {
return $processedData;
}
$flexformData = $this->flexFormService->convertFlexFormContentToArray($originalValue);
// Set the target variable
$targetVariableName = $cObj->stdWrapValue('as', $processorConfiguration);
if (!empty($targetVariableName)) {
$processedData[$targetVariableName] = $flexformData;
} else {
$processedData['data'][$fieldName] = $flexformData;
}
return $processedData;
}
/**
* @param string $key
* @param array $configuration
* @param string $defaultValue
* @param string $expected
* @dataProvider stdWrap_stdWrapValueDataProvider
* @test
*/
public function stdWrap_stdWrapValue($key, array $configuration, $defaultValue, $expected)
{
$result = $this->subject->stdWrapValue($key, $configuration, $defaultValue);
$this->assertEquals($expected, $result);
}
/**
* Get configuration value from processorConfiguration
* with when $dataArrayKey fallback to value from cObj->data array
*
* @param string $key
* @param string|NULL $dataArrayKey
* @return string
*/
protected function getConfigurationValue($key, $dataArrayKey = null)
{
$defaultValue = '';
if ($dataArrayKey && isset($this->contentObjectRenderer->data[$dataArrayKey])) {
$defaultValue = $this->contentObjectRenderer->data[$dataArrayKey];
}
return $this->contentObjectRenderer->stdWrapValue($key, $this->processorConfiguration, $defaultValue);
}
/**
* Get configuration value from processorConfiguration
*
* @param string $key
* @return string
*/
protected function getConfigurationValue($key)
{
return $this->cObj->stdWrapValue($key, $this->processorConfiguration, $this->menuDefaults[$key]);
}
/**
* Process data for a gallery, for instance the CType "textmedia"
*
* @param ContentObjectRenderer $cObj The content object renderer, which contains data of the content element
* @param array $contentObjectConfiguration The configuration of Content Object
* @param array $processorConfiguration The configuration of this processor
* @param array $processedData Key/value store of processed data (e.g. to be passed to a Fluid View)
* @return array the processed data as key/value store
* @throws ContentRenderingException
*/
public function process(ContentObjectRenderer $cObj, array $contentObjectConfiguration, array $processorConfiguration, array $processedData)
{
if (isset($processorConfiguration['if.']) && !$cObj->checkIf($processorConfiguration['if.'])) {
return $processedData;
}
$this->contentObjectRenderer = $cObj;
$this->processorConfiguration = $processorConfiguration;
$filesProcessedDataKey = (string) $cObj->stdWrapValue('filesProcessedDataKey', $processorConfiguration, 'files');
if (isset($processedData[$filesProcessedDataKey]) && is_array($processedData[$filesProcessedDataKey])) {
$this->fileObjects = $processedData[$filesProcessedDataKey];
$this->galleryData['count']['files'] = count($this->fileObjects);
} else {
throw new ContentRenderingException('No files found for key ' . $filesProcessedDataKey . ' in $processedData.', 1436809789);
}
// If carousel is enabled, there is only one column in use
$this->galleryCarousel = (int) $cObj->data['gallery_carousel'];
$this->numberOfColumns = empty($this->galleryCarousel) ? (int) $this->getConfigurationValue('numberOfColumns', 'imagecols') : 1;
$this->mediaOrientation = (int) $this->getConfigurationValue('mediaOrientation', 'imageorient');
$this->maxGalleryWidth = (int) $this->getConfigurationValue('maxGalleryWidth') ?: 1140;
$this->maxGalleryWidthInText = (int) $this->getConfigurationValue('maxGalleryWidthInText') ?: 737;
$this->equalMediaHeight = (int) $this->getConfigurationValue('equalMediaHeight', 'imageheight');
$this->equalMediaWidth = (int) $this->getConfigurationValue('equalMediaWidth', 'imagewidth');
$this->columnSpacing = (int) $this->getConfigurationValue('columnSpacing');
$this->borderEnabled = (bool) $this->getConfigurationValue('borderEnabled', 'imageborder');
$this->borderWidth = (int) $this->getConfigurationValue('borderWidth');
$this->borderPadding = (int) $this->getConfigurationValue('borderPadding');
$this->gridColumns = (int) $this->getConfigurationValue('gridColumns') ?: 12;
$this->galleryResponsiveMinWidth = (int) $this->getConfigurationValue('galleryResponsiveMinWidth') ?: 737;
$this->galleryWidth = (int) $this->getConfigurationValue('galleryWidth', 'gallery_width');
$this->columnClass = $this->getConfigurationValue('columnClass') ?: 'col-xs-(0)';
$this->galleryGridClass = $this->getGalleryGridClass($cObj->data['gallery_break'], $contentObjectConfiguration['settings.']['gallery_break.']);
$this->defaultGalleryWidth = (int) $this->getConfigurationValue('defaultGalleryWidth') ?: 4;
$this->headerAboveContent = (int) $this->getConfigurationValue('headerAboveContent') ?: '0, 1, 2, 8, 9, 10, 17, 18';
$this->galleryAboveContent = (int) $this->getConfigurationValue('galleryAboveContent') ?: '0, 1, 2, 17, 18, 26';
$this->determineGalleryPosition();
$this->determineMaximumGalleryWidth();
$this->determineRelationsToContent();
$this->calculateRowsAndColumns();
$this->calculateMediaWidthsAndHeights();
$this->prepareGalleryData();
$this->extendGalleryData();
$targetFieldName = (string) $cObj->stdWrapValue('as', $processorConfiguration, 'gallery');
$processedData[$targetFieldName] = $this->galleryData;
//\TYPO3\CMS\Extbase\Utility\DebuggerUtility::var_dump($this->galleryData, '$this->galleryData');
return $processedData;
}
