/**
* @test
*/
public function createsValidFieldInterfaceComponents()
{
$instance = $this->buildViewHelperInstance($this->defaultArguments);
$instance->render();
$component = $instance->getComponent(ObjectAccess::getProperty($instance, 'renderingContext', TRUE), ObjectAccess::getProperty($instance, 'arguments', TRUE));
$this->assertInstanceOf('FluidTYPO3\\Flux\\Form\\WizardInterface', $component);
}
/**
* @test
*/
public function supportsForeignMatchFields()
{
$arguments = array('name' => 'test', 'foreignMatchFields' => array('test' => 'test'));
$instance = $this->buildViewHelperInstance($arguments, array());
$component = $instance->getComponent(ObjectAccess::getProperty($instance, 'renderingContext', TRUE), ObjectAccess::getProperty($instance, 'arguments', TRUE));
$this->assertEquals($arguments['foreignMatchFields'], $component->getForeignMatchFields());
}
/**
* Checks if object was changed or not
*
* @param object $object
* @return bool
*/
public static function isDirtyObject($object)
{
foreach (array_keys($object->_getProperties()) as $propertyName) {
try {
$property = ObjectAccess::getProperty($object, $propertyName);
} catch (PropertyNotAccessibleException $e) {
// if property can not be accessed
continue;
}
/**
* std::Property (string, int, etc..),
* PHP-Objects (DateTime, RecursiveIterator, etc...),
* TYPO3-Objects (user, page, etc...)
*/
if (!$property instanceof ObjectStorage) {
if ($object->_isDirty($propertyName)) {
return true;
}
} else {
/**
* ObjectStorage
*/
if ($property->_isDirty()) {
return true;
}
}
}
return false;
}
/**
* @test
*/
public function supportsUseOfControllerAndActionSeparator()
{
$arguments = array('label' => 'Test field', 'controllerExtensionName' => 'Flux', 'pluginName' => 'API', 'controllerName' => 'Flux', 'actions' => array(), 'disableLocalLanguageLabels' => FALSE, 'excludeActions' => array(), 'localLanguageFileRelativePath' => '/Resources/Private/Language/locallang_db.xml', 'prefixOnRequiredArguments' => '*', 'subActions' => array(), 'separator' => ' :: ');
$instance = $this->buildViewHelperInstance($arguments, array(), NULL, $arguments['extensionName'], $arguments['pluginName']);
$instance->initializeArgumentsAndRender();
$component = $instance->getComponent(ObjectAccess::getProperty($instance, 'renderingContext', TRUE), ObjectAccess::getProperty($instance, 'arguments', TRUE));
$this->assertSame($arguments['separator'], $component->getSeparator());
}
/**
* Get a Property from Field by given Marker and Form
*
* @param string $marker Field Marker
* @param Form $form
* @param string $property Field Property
* @return string Property
*/
public function render($marker, Form $form, $property)
{
$field = $this->fieldRepository->findByMarkerAndForm($marker, $form->getUid());
if ($field !== null) {
return ObjectAccess::getProperty($field, $property);
}
return '';
}
/**
* @test
*/
public function canLoadSettings()
{
$instance = $this->createInstance();
$instance->loadSettings($this->defaultData);
foreach ($this->defaultData as $propertyName => $propertyValue) {
$result = ObjectAccess::getProperty($instance, $propertyName, TRUE);
$this->assertEquals($propertyValue, $result);
}
}
/**
* Validates required properties and adds an error for
* each empty property is empty
* Expects an array with property names as keys and
* error codes as values:
* [
* <propertyName> => <errorCode>
* ]
*
* @param $object
* @param array $requiredProperties An array with property names and error codes
* @return void
* @throws \TYPO3\CMS\Extbase\Reflection\Exception\PropertyNotAccessibleException
*/
protected function validateRequiredProperties($object, $requiredProperties)
{
foreach ($requiredProperties as $propertyName => $errorCode) {
$propertyValue = ObjectAccess::getProperty($object, $propertyName);
if ($this->isEmpty($propertyValue)) {
$this->addError($propertyName . ' is required.', $errorCode);
}
}
}
/**
* Load the property value to be used for validation.
*
* In case the object is a doctrine proxy, we need to load the real instance first.
*
* @param object $object
* @param string $propertyName
* @return mixed
*/
protected function getPropertyValue($object, $propertyName)
{
// TODO: add support for lazy loading proxies, if needed
if (ObjectAccess::isPropertyGettable($object, $propertyName)) {
return ObjectAccess::getProperty($object, $propertyName);
} else {
return ObjectAccess::getProperty($object, $propertyName, TRUE);
}
}
/**
* Solution for {outer.{inner}} call in fluid
*
* @param object|array $obj object or array
* @param string $prop property name
* @return mixed
*/
public function render($obj, $prop)
{
if (is_array($obj) && array_key_exists($prop, $obj)) {
return $obj[$prop];
}
if (is_object($obj)) {
return ObjectAccess::getProperty($obj, GeneralUtility::underscoredToLowerCamelCase($prop));
}
return null;
}
/**
* Build array with countries
*
* @param string $key
* @param string $value
* @param string $sortbyField
* @param string $sorting
* @return array
*/
public function getCountries($key = 'isoCodeA3', $value = 'officialNameLocal', $sortbyField = 'isoCodeA3', $sorting = 'asc')
{
$countries = $this->countryRepository->findAllOrderedBy($sortbyField, $sorting);
$countriesArray = [];
foreach ($countries as $country) {
/** @var $country \SJBR\StaticInfoTables\Domain\Model\Country */
$countriesArray[ObjectAccess::getProperty($country, $key)] = ObjectAccess::getProperty($country, $value);
}
return $countriesArray;
}
/**
* @test
*/
public function canTidySourceFromArgument()
{
$instance = $this->createInstance();
if (FALSE === ObjectAccess::getProperty($instance, 'hasTidy', TRUE)) {
return;
}
$source = '<foo> <bar>
</bar> </foo>';
$test = $this->executeViewHelper(array('content' => $source));
$this->assertNotSame($source, $test);
}
/**
* Renders the content.
*
* @param string $extensionName Render partial of this extension
* @param string $partial The partial to render
* @param array $arguments Arguments to pass to the partial
* @return string
*/
public function render($extensionName, $partial = null, array $arguments = array())
{
// Overload arguments with own extension local settings (to pass own settings to external partial)
$arguments = $this->loadSettingsIntoArgumentsNonStatic($arguments);
$oldPartialRootPaths = ObjectAccess::getProperty($this->viewHelperVariableContainer->getView(), 'partialRootPaths', true);
$newPartialRootPaths = array(ExtensionManagementUtility::extPath($extensionName) . 'Resources/Private/Partials');
$this->viewHelperVariableContainer->getView()->setPartialRootPaths($newPartialRootPaths);
$content = $this->viewHelperVariableContainer->getView()->renderPartial($partial, null, $arguments);
$this->viewHelperVariableContainer->getView()->setPartialRootPaths($oldPartialRootPaths);
return $content;
}
/**
* action update
*
* @param User $user
* @validate $user In2code\Femanager\Domain\Validator\ServersideValidator
* @validate $user In2code\Femanager\Domain\Validator\CaptchaValidator
* @return void
*/
public function updateAction(\Gigabonus\Gbfemanager\Domain\Model\User $user = null)
{
if ($user !== NULL && $GLOBALS['TSFE']->fe_user->user['uid'] == $user->getUid()) {
$telephonelastchanged = ObjectAccess::getProperty($user, 'txGbfemanagerTelephonelastchanged');
$user->setTxGbfemanagerTelephonelastchanged(time());
parent::updateAction($user);
} else {
// Versuch die uid im FireBug oder Ähnlichem zu manipulieren
exit;
}
}
/**
* Get all fields from form
*
* @param Form $form
* @param string $property
* @param bool $htmlSpecialChars
* @return array
*/
public function render(Form $form, $property = 'title', $htmlSpecialChars = true)
{
$fields = [];
foreach ($form->getPages() as $page) {
foreach ($page->getFields() as $field) {
$fieldProperty = ObjectAccess::getProperty($field, $property);
if ($htmlSpecialChars) {
$fieldProperty = htmlspecialchars($fieldProperty);
}
$fields[] = $fieldProperty;
}
}
return $fields;
}
/**
* @return AbstractFluxController
*/
protected function createAndTestDummyControllerInstance()
{
$record = Records::$contentRecordWithoutParentAndWithoutChildren;
$record['pi_flexform'] = Xml::SIMPLE_FLEXFORM_SOURCE_DEFAULT_SHEET_ONE_FIELD;
$record['tx_fed_fcefile'] = 'Flux:Default.html';
$frontend = new TypoScriptFrontendController($GLOBALS['TYPO3_CONF_VARS'], 1, 0);
$frontend->cObj = new ContentObjectRenderer();
$frontend->cObj->start($record);
$this->performDummyRegistration();
$controllerClassName = substr(get_class($this), 0, -4);
/** @var AbstractFluxController $instance */
$instance = $this->objectManager->get($controllerClassName);
ObjectAccess::setProperty($instance, 'extensionName', 'Flux', TRUE);
ObjectAccess::getProperty($instance, 'configurationManager', TRUE)->setContentObject($frontend->cObj);
return $instance;
}
/**
* Set properties of an object/array in cobj->LOAD_REGISTER which can then
* be used to be loaded via TS with register:name
*
* @param string $properties comma separated list of properties
* @param mixed $object object or array to get the properties
* @param string $prefix optional prefix
* @return void
*/
public static function setRegisterProperties($properties, $object, $prefix = 'news')
{
if (!empty($properties) && !is_null($object)) {
$cObj = GeneralUtility::makeInstance('TYPO3\\CMS\\Frontend\\ContentObject\\ContentObjectRenderer');
$items = GeneralUtility::trimExplode(',', $properties, TRUE);
$register = array();
foreach ($items as $item) {
$key = $prefix . ucfirst($item);
try {
$register[$key] = \TYPO3\CMS\Extbase\Reflection\ObjectAccess::getProperty($object, $item);
} catch (\Exception $e) {
GeneralUtility::devLog($e->getMessage(), 'news', GeneralUtility::SYSLOG_SEVERITY_WARNING);
}
}
$cObj->LOAD_REGISTER($register, '');
}
}
/**
* Groups the titles to their indexes
*
* @param $titles
* @return array
*/
protected function getAzGrouping($titles)
{
$groupings = [];
$lastChar = '';
foreach ($titles as $title) {
// find titleField and get contents
$objectTitle = \TYPO3\CMS\Extbase\Reflection\ObjectAccess::getProperty($title, $this->configuration['titleField']);
$title->linkObject = [$this->configuration['linkObject'] => $title->getUid()];
$firstLetter = $this->getSpecifiedLetter($objectTitle, 0);
if ($firstLetter != $lastChar) {
$groupings[$firstLetter] = [];
}
array_push($groupings[$firstLetter], $title);
$lastChar = $this->getSpecifiedLetter($objectTitle, 0);
}
return $groupings;
}
/**
* @param string $term
* @return string
*/
public function autocompleteAction($term)
{
$searchProperty = $this->widgetConfiguration['searchProperty'];
$query = $this->widgetConfiguration['objects']->getQuery();
$constraint = $query->getConstraint();
if ($constraint !== null) {
$query->matching($query->logicalAnd($constraint, $query->like($searchProperty, '%' . $term . '%', false)));
} else {
$query->matching($query->like($searchProperty, '%' . $term . '%', false));
}
$results = $query->execute();
$output = [];
foreach ($results as $singleResult) {
$val = \TYPO3\CMS\Extbase\Reflection\ObjectAccess::getProperty($singleResult, $searchProperty);
$output[] = ['id' => $val, 'label' => $val, 'value' => $val];
}
return json_encode($output);
}
/**
* Set properties of an object/array in cobj->LOAD_REGISTER which can then
* be used to be loaded via TS with register:name
*
* @param string $properties comma separated list of properties
* @param mixed $object object or array to get the properties
* @param string $prefix optional prefix
* @return void
*/
public static function setRegisterProperties($properties, $object, $prefix = 'news')
{
if (!empty($properties) && !is_null($object)) {
/** @var ContentObjectRenderer $cObj */
$cObj = GeneralUtility::makeInstance(ContentObjectRenderer::class);
$items = GeneralUtility::trimExplode(',', $properties, true);
$register = [];
foreach ($items as $item) {
$key = $prefix . ucfirst($item);
try {
$register[$key] = \TYPO3\CMS\Extbase\Reflection\ObjectAccess::getProperty($object, $item);
} catch (\Exception $e) {
GeneralUtility::devLog($e->getMessage(), 'news', GeneralUtility::SYSLOG_SEVERITY_WARNING);
}
}
$cObj->cObjGetSingle('LOAD_REGISTER', $register);
}
}
/**
* Sort the array.
*
* @param mixed $records
* @param int $num
* @param string $key
*
* @return mixed|null
*/
private function sortArray($records, $num, $key = 'uid')
{
foreach ($records as $record) {
if (is_array($record)) {
$recordUid = $record[$key];
} elseif ($record instanceof AbstractDomainObject) {
$recordUid = ObjectAccess::getProperty($record, $key);
} elseif (is_object($record)) {
$recordUid = $record->{$key};
} else {
throw new UnexpectedValueException('It is not possible to get key of record');
}
if ((string) $recordUid === (string) $num) {
return $record;
}
}
return null;
}
/**
* Traverses the given object structure in order to transform it into an
* array structure.
*
* @param object $object Object to traverse
* @param array $configuration Configuration for transforming the given object or NULL
* @return array Object structure as an array
*/
protected function transformObject($object, array $configuration)
{
if ($object instanceof \DateTime) {
return $object->format(\DateTime::ISO8601);
} else {
$propertyNames = \TYPO3\CMS\Extbase\Reflection\ObjectAccess::getGettablePropertyNames($object);
$propertiesToRender = array();
foreach ($propertyNames as $propertyName) {
if (isset($configuration['_only']) && is_array($configuration['_only']) && !in_array($propertyName, $configuration['_only'])) {
continue;
}
if (isset($configuration['_exclude']) && is_array($configuration['_exclude']) && in_array($propertyName, $configuration['_exclude'])) {
continue;
}
$propertyValue = \TYPO3\CMS\Extbase\Reflection\ObjectAccess::getProperty($object, $propertyName);
if (!is_array($propertyValue) && !is_object($propertyValue)) {
$propertiesToRender[$propertyName] = $propertyValue;
} elseif (isset($configuration['_descend']) && array_key_exists($propertyName, $configuration['_descend'])) {
$propertiesToRender[$propertyName] = $this->transformValue($propertyValue, $configuration['_descend'][$propertyName]);
}
}
if (isset($configuration['_exposeObjectIdentifier']) && $configuration['_exposeObjectIdentifier'] === TRUE) {
if (isset($configuration['_exposedObjectIdentifierKey']) && strlen($configuration['_exposedObjectIdentifierKey']) > 0) {
$identityKey = $configuration['_exposedObjectIdentifierKey'];
} else {
$identityKey = '__identity';
}
$propertiesToRender[$identityKey] = $this->persistenceManager->getIdentifierByObject($object);
}
if (isset($configuration['_exposeClassName']) && ($configuration['_exposeClassName'] === self::EXPOSE_CLASSNAME_FULLY_QUALIFIED || $configuration['_exposeClassName'] === self::EXPOSE_CLASSNAME_UNQUALIFIED)) {
$className = get_class($object);
$classNameParts = explode('\\', $className);
$propertiesToRender['__class'] = $configuration['_exposeClassName'] === self::EXPOSE_CLASSNAME_FULLY_QUALIFIED ? $className : array_pop($classNameParts);
}
return $propertiesToRender;
}
}
/**
* @test
*/
public function canGetTemplateByActionName()
{
$templatePaths = $this->getFixtureTemplatePaths();
$service = $this->createFluxServiceInstance();
$viewContext = new ViewContext(NULL, 'Flux', 'Content');
$viewContext->setTemplatePaths(new TemplatePaths($templatePaths));
$view = $service->getPreparedExposedTemplateView($viewContext);
$controllerContext = ObjectAccess::getProperty($view, 'controllerContext', TRUE);
$controllerContext->getRequest()->setControllerActionName('dummy');
$controllerContext->getRequest()->setControllerName('Content');
$view->setControllerContext($controllerContext);
$output = $view->getTemplatePathAndFilename('dummy');
$this->assertNotEmpty($output);
$this->assertFileExists($output);
}
/**
* @test
*/
public function canGetGridWhenItDoesNotExistAndStorageDoesNotExist()
{
$form = Form::create();
$instance = $this->createMockedInstanceForVariableContainerTests();
ObjectAccess::getProperty($instance, 'viewHelperVariableContainer', TRUE)->expects($this->any())->method('exists')->will($this->returnValue(FALSE));
ObjectAccess::getProperty($instance, 'templateVariableContainer', TRUE)->expects($this->any())->method('exists')->will($this->returnValue(TRUE));
ObjectAccess::getProperty($instance, 'templateVariableContainer', TRUE)->expects($this->any())->method('get')->will($this->returnValue($form));
$output = $this->callInaccessibleMethod($instance, 'getGrid');
$this->assertInstanceOf('FluidTYPO3\\Flux\\Form\\Container\\Grid', $output);
}
/**
* Converts an object based validation result to an array (can be used to
* be converted for JSON usage).
*
* @param Error\Result|Error\Result[] $validationResult The validation result you want to convert.
* @return array The converted result.
*/
public static function convertValidationResultToArray($validationResult)
{
$validationResultArray = ['errors' => [], 'warnings' => [], 'notices' => []];
foreach ($validationResultArray as $validationName => $validationValue) {
$validationResultArray[$validationName] = [];
if (!is_array($validationResult)) {
$validationResult = [$validationResult];
}
foreach ($validationResult as $validatorResult) {
/** @var Message[] $values */
$values = ObjectAccess::getProperty($validatorResult, $validationName);
foreach ($values as $value) {
$validationResultArray[$validationName][] = $value->render();
}
}
}
return $validationResultArray;
}
/**
* @test
*/
public function canUseFlexFormDataWhenPresent()
{
$instance = $this->canCreateInstanceOfCustomRegisteredController();
$settings = array('settings' => array('test' => 'test'));
ObjectAccess::setProperty($instance, 'data', $settings, TRUE);
$this->callInaccessibleMethod($instance, 'initializeProvider');
$this->callInaccessibleMethod($instance, 'initializeOverriddenSettings');
$overriddenSettings = ObjectAccess::getProperty($instance, 'settings', TRUE);
$this->assertEquals($settings['settings']['test'], $overriddenSettings['test']);
}
/**
* @test
*/
public function getPropertyCanAccessPropertiesOfAnArray()
{
$array = array('key' => 'value');
$expected = \TYPO3\CMS\Extbase\Reflection\ObjectAccess::getProperty($array, 'key');
$this->assertEquals($expected, 'value', 'getProperty does not work with Array property.');
}
/**
* @param array $row
* @param string $propertyPath
* @return mixed
*/
protected function getInheritedPropertyValueByDottedPath(array $row, $propertyPath)
{
$tree = $this->getInheritanceTree($row);
$inheritedConfiguration = $this->getMergedConfiguration($tree);
if (FALSE === strpos($propertyPath, '.')) {
return TRUE === isset($inheritedConfiguration[$propertyPath]) ? ObjectAccess::getProperty($inheritedConfiguration, $propertyPath) : NULL;
}
return ObjectAccess::getPropertyPath($inheritedConfiguration, $propertyPath);
}
/**
* @param QueryInterface $query
* @return array
*/
protected function addOptionsFromResults(QueryInterface $query)
{
$items = array();
$results = $query->execute();
$type = $query->getType();
$table = strtolower(str_replace('\\', '_', $type));
$propertyName = $this->getLabelPropertyName($table, $type);
foreach ($results as $result) {
$uid = $result->getUid();
array_push($items, array(ObjectAccess::getProperty($result, $propertyName), $uid));
}
return $items;
}
/**
* @param string $name
* @param bool $useRawKeys
*
* @return mixed
*/
public function render($name, $useRawKeys = false)
{
if (false === strpos($name, '.')) {
if (true === $this->templateVariableContainer->exists($name)) {
return $this->templateVariableContainer->get($name);
}
} else {
$segments = explode('.', $name);
$lastSegment = array_shift($segments);
$templateVariableRootName = $lastSegment;
if (true === $this->templateVariableContainer->exists($templateVariableRootName)) {
$templateVariableRoot = $this->templateVariableContainer->get($templateVariableRootName);
if (true === $useRawKeys) {
return ObjectAccess::getPropertyPath($templateVariableRoot, implode('.', $segments));
}
try {
$value = $templateVariableRoot;
foreach ($segments as $segment) {
if (true === ctype_digit($segment)) {
$segment = intval($segment);
$index = 0;
// Note: this loop approach is not a stupid solution. If you doubt this,
// attempt to feth a number at a numeric index from ObjectStorage ;)
foreach ($value as $possibleValue) {
if ($index === $segment) {
$value = $possibleValue;
break;
}
++$index;
}
continue;
}
$value = ObjectAccess::getProperty($value, $segment);
}
return $value;
} catch (\Exception $e) {
return;
}
}
}
}
/**
* Gets the value to use as sorting value from $object
*
* @param mixed $object
* @return mixed
*/
protected function getSortValue($object)
{
$field = $this->arguments['sortBy'];
$value = \TYPO3\CMS\Extbase\Reflection\ObjectAccess::getProperty($object, $field);
if ($value instanceof \DateTime) {
$value = $value->format('U');
} elseif ($value instanceof \TYPO3\CMS\Extbase\Persistence\ObjectStorage) {
$value = $value->count();
} elseif (is_array($value)) {
$value = count($value);
}
return $value;
}