/**
*/
public function setUp()
{
ComposerUtility::flushCaches();
vfsStream::setup('Packages');
$this->mockPackageManager = $this->getMockBuilder(\TYPO3\Flow\Package\PackageManager::class)->disableOriginalConstructor()->getMock();
ObjectAccess::setProperty($this->mockPackageManager, 'composerManifestData', array(), true);
}
/**
* @return void
*/
public function up()
{
$affectedViewHelperClassNames = array();
$allPathsAndFilenames = Files::readDirectoryRecursively($this->targetPackageData['path'], '.php', TRUE);
foreach ($allPathsAndFilenames as $pathAndFilename) {
if (substr($pathAndFilename, -14) !== 'ViewHelper.php') {
continue;
}
$fileContents = file_get_contents($pathAndFilename);
$className = (new PhpAnalyzer($fileContents))->extractFullyQualifiedClassName();
if ($className === NULL) {
$this->showWarning(sprintf('could not extract class name from file "%s"', $pathAndFilename));
continue;
}
/** @noinspection PhpIncludeInspection */
require_once $pathAndFilename;
if (!class_exists($className)) {
$this->showWarning(sprintf('could not load class "%s" extracted from file "%s"', $className, $pathAndFilename));
continue;
}
$instance = new $className();
$escapeOutput = ObjectAccess::getProperty($instance, 'escapeOutput', TRUE);
if ($escapeOutput !== NULL) {
continue;
}
$affectedViewHelperClassNames[] = $className;
$this->searchAndReplaceRegex('/\\R\\s*class[^\\{]+\\R?\\{(\\s*)(?=.*?\\})/s', '$0' . "\n\t" . '/**' . "\n\t" . ' * NOTE: This property has been introduced via code migration to ensure backwards-compatibility.' . "\n\t" . ' * @see AbstractViewHelper::isOutputEscapingEnabled()' . "\n\t" . ' * @var boolean' . "\n\t" . ' */' . "\n\t" . 'protected $escapeOutput = FALSE;$1', $pathAndFilename);
}
if ($affectedViewHelperClassNames !== array()) {
$this->showWarning('Added "escapeOutput" property to following ViewHelpers:' . PHP_EOL . ' * ' . implode(PHP_EOL . ' * ', $affectedViewHelperClassNames) . PHP_EOL . PHP_EOL . 'If an affected ViewHelper does not render HTML output, you should set this property TRUE in order to ensure sanitization of the output!');
}
$this->addWarningsForAffectedViewHelpers($this->targetPackageData['path']);
}
/**
* Mocks an entity as wished
*
* @param string $fqcn the fully qualified class name
* @param boolean $persist if the entity should be directly persisted or not
* @param array $customProperties the properties to set if wished
* @return Object
*/
public function create($fqcn, $persist = false, $customProperties = array())
{
$entityConfiguration = $this->entityConfiguration[$fqcn];
$this->validateEntityConfiguration($fqcn, $entityConfiguration);
// create from reflection class if constructor needs arguments
if (!empty($entityConfiguration['constructorArguments'])) {
$reflector = new \ReflectionClass($fqcn);
$constructorArguments = $this->getValuesFromConfigurations($entityConfiguration['constructorArguments']);
$entity = $reflector->newInstanceArgs($constructorArguments);
} else {
$entity = new $fqcn();
}
// set the properties
$configuredProperties = $entityConfiguration['properties'] ?: array();
$properties = array_merge($configuredProperties, $customProperties);
foreach ($this->getValuesFromConfigurations($properties, $persist) as $propertyName => $propertyValue) {
$propertyCouldBeSet = ObjectAccess::setProperty($entity, $propertyName, $propertyValue);
if (!$propertyCouldBeSet) {
throw new \Exception($fqcn . '::$' . $propertyName . ' could not be set to ' . print_r($propertyValue, true), 1416481470);
}
}
// persist if wished
if ($persist && is_string($entityConfiguration['repository'])) {
$this->objectManager->get($entityConfiguration['repository'])->add($entity);
// flush this entity here...
$this->entityManager->flush($entity);
// add to managed entities
$identifier = $this->persistenceManager->getIdentifierByObject($entity);
$this->managedEntities[$identifier] = $entity;
}
return $entity;
}
public function assertPersistedPropertyValue($entity, $propertyName, $expectedPropertyValue, $forceDirectAccess = true)
{
$this->entityManager->refresh($entity);
$persistedPropertyValue = ObjectAccess::getProperty($entity, $propertyName, $forceDirectAccess);
$this->test->assertSame($expectedPropertyValue, $persistedPropertyValue, 'The property ' . $propertyName . ' did not have the expected persistent value');
return $this;
}
/**
* See the configuration in Testing/Objects.yaml
* @test
*/
public function configuredObjectDWillGetAssignedObjectFWithCorrectlyConfiguredConstructorValue()
{
$instance = $this->objectManager->get(\TYPO3\Flow\Tests\Functional\Object\Fixtures\PrototypeClassD::class);
/** @var $instanceE Fixtures\PrototypeClassE */
$instanceE = ObjectAccess::getProperty($instance, 'objectE', TRUE);
$this->assertEquals('The constructor set value', $instanceE->getNullValue());
}
/**
* @param string $term
* @return string
*/
public function autocompleteAction($term)
{
$searchProperty = $this->widgetConfiguration['searchProperty'];
/** @var $queryResult QueryResultInterface */
$queryResult = $this->widgetConfiguration['objects'];
$query = clone $queryResult->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));
}
if (isset($this->configuration['limit'])) {
$query->setLimit((int) $this->configuration['limit']);
}
$results = $query->execute();
$output = array();
$values = array();
foreach ($results as $singleResult) {
$val = ObjectAccess::getPropertyPath($singleResult, $searchProperty);
if (isset($values[$val])) {
continue;
}
$values[$val] = TRUE;
$output[] = array('id' => $val, 'label' => $val, 'value' => $val);
}
return json_encode($output);
}
/**
*
*/
public function setUp()
{
$this->queueManager = new QueueManager();
$this->queueManager->injectSettings(array('queues' => array('TestQueue' => array('className' => 'TYPO3\\Jobqueue\\Common\\Tests\\Unit\\Fixtures\\TestQueue'))));
$this->jobManager = new JobManager();
ObjectAccess::setProperty($this->jobManager, 'queueManager', $this->queueManager, true);
}
/**
* Log a message if a post is deleted
*
* @param \TYPO3\Flow\Aop\JoinPointInterface $joinPoint
* @Flow\Around("method(TYPO3\Neos\View\TypoScriptView->render())")
* @return void
*/
public function replacePlaceholdersIfNecessary(\TYPO3\Flow\Aop\JoinPointInterface $joinPoint)
{
$result = $joinPoint->getAdviceChain()->proceed($joinPoint);
/* @var $typoScriptView TypoScriptView */
$typoScriptView = $joinPoint->getProxy();
$viewVariables = ObjectAccess::getProperty($typoScriptView, 'variables', TRUE);
if (!isset($viewVariables['value']) || !$viewVariables['value']->getNodeType()->isOfType('Sandstorm.Newsletter:Newsletter')) {
// No newsletter, so logic does not apply
return $result;
}
/* @var $httpRequest Request */
$httpRequest = $this->controllerContext->getRequest()->getHttpRequest();
$arguments = $httpRequest->getUri()->getArguments();
if (!isset($arguments['hmac'])) {
if ($this->securityContext->isInitialized() && $this->securityContext->hasRole('TYPO3.Neos:Editor')) {
// Logged into backend, so we don't need to do anything.
return $result;
} else {
// No HMAC sent -- so we return the email INCLUDING placeholders (as per customer's request)
return $result;
//return '<h1>Error: HMAC not included in the link.</h1>';
}
}
$actualHmac = $arguments['hmac'];
$uriWithoutHmac = str_replace('&hmac=' . $actualHmac, '', (string) $httpRequest->getUri());
$expectedHmac = hash_hmac('sha1', urldecode($uriWithoutHmac), $this->hmacUrlSecret);
if ($expectedHmac !== $actualHmac) {
return '<h1>Error: Wrong link clicked.</h1>Please contact your administrator for help';
}
$result = preg_replace_callback(ReplacePlaceholdersInLiveImplementation::PLACEHOLDER_REGEX, function ($element) use($arguments) {
return ObjectAccess::getPropertyPath($arguments, $element[1]);
}, $result);
return $result;
}
/**
* @test
*/
public function convertFromUsesAppropriatePropertyPopulationMethodsInOrderConstructorSetterPublic()
{
$convertedObject = $this->converter->convertFrom('irrelevant', \TYPO3\Flow\Tests\Functional\Property\Fixtures\TestClass::class, array('propertyMeantForConstructorUsage' => 'theValue', 'propertyMeantForSetterUsage' => 'theValue', 'propertyMeantForPublicUsage' => 'theValue'), new PropertyMappingConfiguration());
$this->assertEquals('theValue set via Constructor', ObjectAccess::getProperty($convertedObject, 'propertyMeantForConstructorUsage', true));
$this->assertEquals('theValue set via Setter', ObjectAccess::getProperty($convertedObject, 'propertyMeantForSetterUsage', true));
$this->assertEquals('theValue', ObjectAccess::getProperty($convertedObject, 'propertyMeantForPublicUsage', true));
}
/**
* Change the property on the given node.
*
* @param NodeData $node
* @return void
*/
public function execute(NodeData $node)
{
foreach ($node->getNodeType()->getProperties() as $propertyName => $propertyConfiguration) {
if (isset($propertyConfiguration['type']) && in_array(trim($propertyConfiguration['type']), $this->getHandledObjectTypes())) {
if (!isset($nodeProperties)) {
$nodeRecordQuery = $this->entityManager->getConnection()->prepare('SELECT properties FROM typo3_typo3cr_domain_model_nodedata WHERE persistence_object_identifier=?');
$nodeRecordQuery->execute([$this->persistenceManager->getIdentifierByObject($node)]);
$nodeRecord = $nodeRecordQuery->fetch(\PDO::FETCH_ASSOC);
$nodeProperties = unserialize($nodeRecord['properties']);
}
if (!isset($nodeProperties[$propertyName]) || !is_object($nodeProperties[$propertyName])) {
continue;
}
/** @var Asset $assetObject */
$assetObject = $nodeProperties[$propertyName];
$nodeProperties[$propertyName] = null;
$stream = $assetObject->getResource()->getStream();
if ($stream === false) {
continue;
}
fclose($stream);
$objectType = TypeHandling::getTypeForValue($assetObject);
$objectIdentifier = ObjectAccess::getProperty($assetObject, 'Persistence_Object_Identifier', true);
$nodeProperties[$propertyName] = array('__flow_object_type' => $objectType, '__identifier' => $objectIdentifier);
}
}
if (isset($nodeProperties)) {
$nodeUpdateQuery = $this->entityManager->getConnection()->prepare('UPDATE typo3_typo3cr_domain_model_nodedata SET properties=? WHERE persistence_object_identifier=?');
$nodeUpdateQuery->execute([serialize($nodeProperties), $this->persistenceManager->getIdentifierByObject($node)]);
}
}
/**
*/
public function setUp()
{
vfsStream::setup('Packages');
$this->mockPackageManager = $this->getMockBuilder('TYPO3\\Flow\\Package\\PackageManager')->disableOriginalConstructor()->getMock();
ObjectAccess::setProperty($this->mockPackageManager, 'composerManifestData', array(), TRUE);
$this->packageFactory = new PackageFactory($this->mockPackageManager);
}
/**
* @param string $type
* @param array $bookableRequests
* @return Registration\AbstractBookable[]
*/
protected function requestBookable($type, $bookableRequests)
{
/** @var \T3DD\Backend\Domain\Repository\Registration\AbstractBookableRepository $repository */
$repository = $this->{strtolower($type) . 'Repository'};
$fractionBase = (int) isset($this->configuration[$type]['fractionBase']) ? $this->configuration[$type]['fractionBase'] : static::DEFAULT_FRACTION_BASE;
$availableQuota = (int) isset($this->configuration[$type]['availableQuota']) ? $this->configuration[$type]['availableQuota'] * $fractionBase : 0;
$spentQuota = $repository->getSpentQuota();
$requestedBookables = [];
foreach ($bookableRequests as $bookableRequest) {
$requestFraction = round($fractionBase / $bookableRequest['divisor']);
$quotaApplies = (bool) isset($bookableRequest['quotaApplies']) ? $bookableRequest['quotaApplies'] : TRUE;
$className = 'T3DD\\Backend\\Domain\\Model\\Registration\\' . $type;
$requestedBookable = new $className();
$requestedBookable->setFraction($requestFraction);
$requestedBookable->setQuotaApplies($quotaApplies);
\TYPO3\Flow\Reflection\ObjectAccess::setProperty($bookableRequest['participant'], $type, $requestedBookable);
if (!$quotaApplies) {
$requestedBookable->setBookingState(Registration\AbstractBookable::BOOKING_STATE_PENDING);
} else {
$spentQuota += $requestFraction;
if ($spentQuota > $availableQuota) {
$requestedBookable->setBookingState(Registration\AbstractBookable::BOOKING_STATE_WAITING);
} else {
$requestedBookable->setBookingState(Registration\AbstractBookable::BOOKING_STATE_PENDING);
}
}
$requestedBookables[] = $requestedBookable;
$repository->add($requestedBookable);
}
return $requestedBookables;
}
/**
* @Flow\Before("method(TYPO3\Neos\Controller\Backend\ContentController->uploadAssetAction())")
* @param JoinPointInterface $joinPoint The current join point
* @return void
*/
public function rewriteSiteAssetCollection(JoinPointInterface $joinPoint)
{
if ($this->lookupNodeFilter === NULL || $this->lookupPropertyName === NULL) {
return;
}
/** @var ContentController $contentController */
$contentController = $joinPoint->getProxy();
/** @var ActionRequest $actionRequest */
$actionRequest = ObjectAccess::getProperty($contentController, 'request', TRUE);
$nodeContextPath = $actionRequest->getInternalArgument('__node');
if ($nodeContextPath === NULL) {
return;
}
$node = $this->propertyMapper->convert($nodeContextPath, NodeInterface::class);
$flowQuery = new FlowQuery(array($node));
/** @var NodeInterface $documentNode */
$documentNode = $flowQuery->closest($this->lookupNodeFilter)->get(0);
if (!$documentNode->hasProperty($this->lookupPropertyName)) {
return;
}
/** @var AssetCollection $assetCollection */
$assetCollection = $this->assetCollectionRepository->findByIdentifier($documentNode->getProperty($this->lookupPropertyName));
if ($assetCollection === NULL) {
return;
}
/** @var Asset $asset */
$asset = $joinPoint->getMethodArgument('asset');
$assetCollection->addAsset($asset);
$this->assetCollectionRepository->update($assetCollection);
}
public function boot(\TYPO3\Flow\Core\Bootstrap $bootstrap)
{
// 1. Make Gedmo\Translatable\Entity\Translation known to Doctrine, so that it can participate in Database Schema Generation
//
// Internally, we use a MappingDriverChain for that, which delegates almost all of its behavior to the already-existing
// FlowAnnotationDriver. We additionally add the (default doctrine) Annotation Driver for the Gedmo namespace.
//
// Note: We replace FlowAnnotationDriver *on a very low level* with the *MappingDriverChain* object; because this class
// is only used inside EntityManagerFactory -- so we know quite exactly what methods are called on that object.
$bootstrap->getSignalSlotDispatcher()->connect('TYPO3\\Flow\\Core\\Booting\\Sequence', 'beforeInvokeStep', function ($step) use($bootstrap) {
if ($step->getIdentifier() === 'typo3.flow:resources') {
$flowAnnotationDriver = $bootstrap->getObjectManager()->get('TYPO3\\Flow\\Persistence\\Doctrine\\Mapping\\Driver\\FlowAnnotationDriver');
$driverChain = new MappingDriverChainWithFlowAnnotationDriverAsDefault($flowAnnotationDriver);
$driverChain->addDriver(new AnnotationDriver(ObjectAccess::getProperty($flowAnnotationDriver, 'reader', TRUE), FLOW_PATH_PACKAGES . 'Libraries/gedmo/doctrine-extensions/lib/Gedmo/Translatable/Entity'), 'Gedmo');
$bootstrap->getObjectManager()->setInstance('TYPO3\\Flow\\Persistence\\Doctrine\\Mapping\\Driver\\FlowAnnotationDriver', $driverChain);
}
});
// 2. Work around a bug in TYPO3\Flow\Persistence\Doctrine\PersistenceManager::onFlush which expects that all objects in the
// Doctrine subsystem are entities known to Flow.
//
// The line $this->reflectionService->getClassSchema($entity)->getModelType() triggers a fatal error, for get_class($entity) == 'Gedmo\Translatable\Entity\Translation'
// because this class is known only to Doctrine (see 1. above), but not to the Flow reflection service.
//
// As a workaround, we just add an empty placeholder class schema to the Class Schemata cache, right before the class schema is saved
// inside the TYPO3\Flow\Core\Bootstrap::bootstrapShuttingDown signal (which is fired directly after "finishedCompiletimeRun").
$bootstrap->getSignalSlotDispatcher()->connect('TYPO3\\Flow\\Core\\Bootstrap', 'finishedCompiletimeRun', function () use($bootstrap) {
$classSchemataCache = $bootstrap->getObjectManager()->get('TYPO3\\Flow\\Cache\\CacheManager')->getCache('Flow_Reflection_RuntimeClassSchemata');
if (!$classSchemataCache->has('Gedmo_Translatable_Entity_Translation')) {
$classSchemataCache->set('Gedmo_Translatable_Entity_Translation', new ClassSchema('Gedmo\\Translatable\\Entity\\Translation'));
}
});
}
/**
* Add DQL function
*
* @param \TYPO3\Flow\Aop\JoinPointInterface $joinPoint The current join point
* @Flow\Before("method(TYPO3\Flow\Persistence\Doctrine\Service->runDql())")
* @return void
*/
public function addDqlFunction(\TYPO3\Flow\Aop\JoinPointInterface $joinPoint)
{
$entityManager = \TYPO3\Flow\Reflection\ObjectAccess::getProperty($joinPoint->getProxy(), 'entityManager', TRUE);
$configuration = \TYPO3\Flow\Reflection\ObjectAccess::getProperty($entityManager, 'config', TRUE);
$configuration->addCustomStringFunction('DAY', 'Lelesys\\Plugin\\News\\Doctrine\\Query\\Mysql\\Day');
$configuration->addCustomStringFunction('MONTH', 'Lelesys\\Plugin\\News\\Doctrine\\Query\\Mysql\\Month');
$configuration->addCustomStringFunction('YEAR', 'Lelesys\\Plugin\\News\\Doctrine\\Query\\Mysql\\Year');
}
/**
* The input is assumed to be an array or Collection of objects. Groups this input by the $groupingKey property of each element.
*
* @param array|Collection $set
* @param string $groupingKey
* @return array
*/
public function groupBy($set, $groupingKey)
{
$result = array();
foreach ($set as $element) {
$result[ObjectAccess::getPropertyPath($element, $groupingKey)][] = $element;
}
return $result;
}
/**
* @test
*/
public function collectionValidatorIsValidEarlyReturnsOnUnitializedDoctrinePersistenceCollections()
{
$entityManager = $this->getMock(\Doctrine\ORM\EntityManager::class, array(), array(), '', false);
$collection = new \Doctrine\Common\Collections\ArrayCollection(array());
$persistentCollection = new \Doctrine\ORM\PersistentCollection($entityManager, '', $collection);
\TYPO3\Flow\Reflection\ObjectAccess::setProperty($persistentCollection, 'initialized', false, true);
$this->mockValidatorResolver->expects($this->never())->method('createValidator');
$this->validator->validate($persistentCollection);
}
/**
* @param JoinPointInterface $joinPoint
* @return mixed Result of the target method
* @Flow\Around("class(TYPO3\Flow\Cli\Request) && method(.*->getCommand())")
*/
public function replaceCommandWithDomainCommand(JoinPointInterface $joinPoint)
{
/** @var Request $proxy */
$proxy = $joinPoint->getProxy();
if ($proxy->getControllerObjectName() === DomainCommandController::class) {
ObjectAccess::setProperty($proxy, 'command', $this->buildDomainCommand($proxy->getControllerCommandName()), TRUE);
}
return $joinPoint->getAdviceChain()->proceed($joinPoint);
}
/**
* @param string $propertyPath
* @return string
*/
public function render($propertyPath = 'party.name')
{
$tokens = $this->securityContext->getAuthenticationTokens();
foreach ($tokens as $token) {
if ($token->isAuthenticated()) {
return (string) \TYPO3\Flow\Reflection\ObjectAccess::getPropertyPath($token->getAccount(), $propertyPath);
}
}
return '';
}
/**
* Returns TRUE if the given node is of the node type this filter expects.
*
* @param \TYPO3\TYPO3CR\Domain\Model\NodeInterface $node
* @return boolean
*/
public function matches(\TYPO3\TYPO3CR\Domain\Model\NodeInterface $node)
{
if ($this->withSubTypes === TRUE) {
return $this->nodeTypeManager->getNodeType($node->getNodeType())->isOfType($this->nodeTypeName);
} else {
$nodeData = \TYPO3\Flow\Reflection\ObjectAccess::getProperty($node, 'nodeData', TRUE);
$nodeType = \TYPO3\Flow\Reflection\ObjectAccess::getProperty($nodeData, 'nodeType', TRUE);
return $nodeType === $this->nodeTypeName;
}
}
/**
* @param array $row
* @return object
*/
public function hydrate(array $row)
{
$dto = $this->getNewDtoInstance();
foreach ($row as $column => $value) {
if (ObjectAccess::isPropertySettable($dto, $column)) {
ObjectAccess::setProperty($dto, $column, $value);
}
}
return $dto;
}
/**
* @return void
*/
public function up()
{
$this->processConfiguration(ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, function (array &$configuration) {
$presetsConfiguration = \TYPO3\Flow\Reflection\ObjectAccess::getPropertyPath($configuration, 'TYPO3.Form.presets');
if (!is_array($presetsConfiguration)) {
return;
}
$presetsConfiguration = $this->renameTranslationPackage($presetsConfiguration);
$configuration['TYPO3']['Form']['presets'] = $presetsConfiguration;
}, true);
}
/**
* Builds a transformation object from the given configuration.
*
* @param array $transformationConfiguration
* @return \TYPO3\TYPO3CR\Migration\Transformations\TransformationInterface
* @throws \TYPO3\TYPO3CR\Migration\Exception\MigrationException if a given setting is not supported
*/
protected function buildTransformationObject($transformationConfiguration)
{
$transformationClassName = $this->resolveTransformationClassName($transformationConfiguration['type']);
$transformation = new $transformationClassName();
foreach ($transformationConfiguration['settings'] as $settingName => $settingValue) {
if (!\TYPO3\Flow\Reflection\ObjectAccess::setProperty($transformation, $settingName, $settingValue)) {
throw new \TYPO3\TYPO3CR\Migration\Exception\MigrationException('Cannot set setting "' . $settingName . '" on transformation "' . $transformationClassName . '" , check your configuration.', 1343293094);
}
}
return $transformation;
}
/**
* Advice for uncached segments when rendering from a cached version
*
* @Flow\AfterReturning("method(TYPO3\TypoScript\Core\Cache\RuntimeContentCache->evaluateUncached())")
* @param JoinPointInterface $joinPoint
*/
public function registerEvaluateUncached(JoinPointInterface $joinPoint)
{
$path = $joinPoint->getMethodArgument('path');
$proxy = $joinPoint->getProxy();
/** @var Runtime $runtime */
$runtime = ObjectAccess::getProperty($proxy, 'runtime', TRUE);
$mocVarnishIgnoreUncached = $runtime->evaluate($path . '/__meta/cache/mocVarnishIgnoreUncached');
if ($mocVarnishIgnoreUncached !== TRUE) {
$this->evaluatedUncached = TRUE;
}
}
/**
* @param array $options
* @return void
*/
public function addOptions(array $options)
{
foreach ($options as $key => $value) {
$setterName = $setterName = ObjectAccess::buildSetterMethodName($key);
if (method_exists($this, $setterName)) {
$this->{$setterName}($value);
} else {
$this->setOption($key, $value);
}
}
}
/**
* Finds ort as per entered search string
*
* @param string $searchString The entered search string
* @return \TYPO3\Flow\Persistence\QueryResultInterface The ort
*/
public function findOrtBySearchString($searchString)
{
$searchString = trim($searchString);
$searchString = '%' . $searchString . '%';
$query = $this->createQuery();
/** @var $queryBuilder \Doctrine\ORM\QueryBuilder **/
$queryBuilder = ObjectAccess::getProperty($query, 'queryBuilder', true);
$queryBuilder->resetDQLParts()->select('ort')->from('\\Subugoe\\GermaniaSacra\\Domain\\Model\\Ort', 'ort')->innerJoin('ort.bistum', 'bistum')->where('ort.ort LIKE :ort')->orderBy('ort.ort', 'ASC');
$queryBuilder->setParameter('ort', $searchString);
return $query->execute();
}
/**
* @Given /^I have the following policies:$/
*/
public function iHaveTheFollowingPolicies($string)
{
self::$testingPolicyPathAndFilename = $this->environment->getPathToTemporaryDirectory() . 'Policy.yaml';
file_put_contents(self::$testingPolicyPathAndFilename, $string->getRaw());
$configurationManager = $this->objectManager->get('TYPO3\\Flow\\Configuration\\ConfigurationManager');
$configurations = \TYPO3\Flow\Reflection\ObjectAccess::getProperty($configurationManager, 'configurations', TRUE);
unset($configurations[\TYPO3\Flow\Configuration\ConfigurationManager::CONFIGURATION_PROCESSING_TYPE_POLICY]);
\TYPO3\Flow\Reflection\ObjectAccess::setProperty($configurationManager, 'configurations', $configurations, TRUE);
$policyService = $this->objectManager->get('TYPO3\\Flow\\Security\\Policy\\PolicyService');
\TYPO3\Flow\Reflection\ObjectAccess::setProperty($policyService, 'initialized', FALSE, TRUE);
}
/**
* Updates the identifier credential from the GET/POST vars, if the GET/POST parameters
* are available. Sets the authentication status to AUTHENTICATION_NEEDED, if credentials have been sent.
*
* Note: You need to send the password in this parameter:
* __authentication[_OurBrand_][Quiz][Security][IdentifierToken][identifier]
*
* @param \TYPO3\Flow\Mvc\ActionRequest $actionRequest The current action request
* @return void
*/
public function updateCredentials(\TYPO3\Flow\Mvc\ActionRequest $actionRequest)
{
$postArguments = $actionRequest->getInternalArguments();
$username = \TYPO3\Flow\Reflection\ObjectAccess::getPropertyPath($postArguments, '__authentication._OurBrand_.Quiz.Security.IdentifierToken.username');
$password = \TYPO3\Flow\Reflection\ObjectAccess::getPropertyPath($postArguments, '__authentication._OurBrand_.Quiz.Security.IdentifierToken.password');
if (!empty($username) && !empty($password)) {
$this->credentials['username'] = $username;
$this->credentials['password'] = $password;
$this->setAuthenticationStatus(self::AUTHENTICATION_NEEDED);
}
}
/**
* @test
*/
public function ignoredClassesCanBeOverwrittenBySettings()
{
$object = new ApplicationContext('Development');
$this->assertEquals('TYPO3\\Flow\\Core\\ApplicationContext prototype object', Debugger::renderDump($object, 10, TRUE));
Debugger::clearState();
$currentConfiguration = ObjectAccess::getProperty($this->configurationManager, 'configurations', TRUE);
$configurationOverwrite['Settings']['TYPO3']['Flow']['error']['debugger']['ignoredClasses']['TYPO3\\\\Flow\\\\Core\\\\.*'] = FALSE;
$newConfiguration = Arrays::arrayMergeRecursiveOverrule($currentConfiguration, $configurationOverwrite);
ObjectAccess::setProperty($this->configurationManager, 'configurations', $newConfiguration, TRUE);
$this->assertContains('rootContextString', Debugger::renderDump($object, 10, TRUE));
}
/**
* Returns contents of Composer manifest - or part there of.
*
* @param string $manifestPath
* @param string $configurationPath Optional. Only return the part of the manifest indexed by configurationPath
* @return array|mixed
*/
public static function getComposerManifest($manifestPath, $configurationPath = null)
{
$composerManifest = static::readComposerManifest($manifestPath);
if ($composerManifest === null) {
return null;
}
if ($configurationPath !== null) {
return ObjectAccess::getPropertyPath($composerManifest, $configurationPath);
} else {
return $composerManifest;
}
}