/** * In this method, actually create the user / account. * * NOTE: After this method is called, the $registrationFlow is DESTROYED, so you need to store all attributes * in your object as you need them. * * @param RegistrationFlow $registrationFlow * @return void */ public function createUserAndAccount(RegistrationFlow $registrationFlow) { // Create the account $account = new Account(); $account->setAccountIdentifier($registrationFlow->getEmail()); $account->setCredentialsSource($registrationFlow->getEncryptedPassword()); $account->setAuthenticationProviderName('Sandstorm.UserManagement:Login'); // Assign pre-configured roles foreach ($this->rolesForNewUsers as $roleString) { $account->addRole(new Role($roleString)); } // Create the user $user = new User(); $user->setAccount($account); $user->setEmail($registrationFlow->getEmail()); if (array_key_exists('salutation', $registrationFlow->getAttributes())) { $user->setGender($registrationFlow->getAttributes()['salutation']); } if (array_key_exists('firstName', $registrationFlow->getAttributes())) { $user->setFirstName($registrationFlow->getAttributes()['firstName']); } if (array_key_exists('lastName', $registrationFlow->getAttributes())) { $user->setLastName($registrationFlow->getAttributes()['lastName']); } // Persist user $this->userRepository->add($user); $this->persistenceManager->whitelistObject($user); $this->persistenceManager->whitelistObject($account); }
/** * @param mixed $source * @param \Flowpack\ElasticSearch\Annotations\Transform $annotation * @return string */ public function transformByAnnotation($source, \Flowpack\ElasticSearch\Annotations\Transform $annotation) { if ($source != null) { return $this->persistenceManager->getIdentifierByObject($source); } return ''; }
/** * @param \DLigo\Animaltool\Domain\Model\Animal $animal */ public function findByAnimal($animal) { $id = $this->persistenceManager->getIdentifierByObject($animal); $query = $this->createQuery(); $query->matching($query->equals('animalId', $id))->setOrderings(array('time' => \TYPO3\Flow\Persistence\QueryInterface::ORDER_DESCENDING)); return $query->execute(); }
/** * Executes this finisher * @see AbstractFinisher::execute() * * @return void * @throws \TYPO3\Flow\Mvc\Exception\StopActionException(); */ protected function executeInternal() { /** @var \TYPO3\Form\Core\Runtime\FormRuntime $formRuntime */ $formRuntime = $this->finisherContext->getFormRuntime(); $formValueArray = $formRuntime->getFormState()->getFormValues(); /** @var \GIB\GradingTool\Domain\Model\Project $project */ $project = $this->projectRepository->findByIdentifier($formRuntime->getRequest()->getParentRequest()->getArgument('project')); // store changes to project $project->setProjectData($formValueArray); $this->projectRepository->update($project); // add a flash message $message = new \TYPO3\Flow\Error\Message('The project data for "%s" was successfully edited.', \TYPO3\Flow\Error\Message::SEVERITY_OK, array($project->getProjectTitle())); $this->flashMessageContainer->addMessage($message); $this->persistenceManager->persistAll(); // redirect to dashboard $formRuntime = $this->finisherContext->getFormRuntime(); $request = $formRuntime->getRequest()->getMainRequest(); $uriBuilder = new \TYPO3\Flow\Mvc\Routing\UriBuilder(); $uriBuilder->setRequest($request); $uriBuilder->reset(); $uri = $uriBuilder->uriFor('index', NULL, 'Admin'); $response = $formRuntime->getResponse(); $mainResponse = $response; while ($response = $response->getParentResponse()) { $mainResponse = $response; } $mainResponse->setStatus(303); $mainResponse->setHeader('Location', (string) $uri); throw new \TYPO3\Flow\Mvc\Exception\StopActionException(); }
/** * 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)]); } }
/** * @test */ public function renderWithoutValueInvokesRenderChildren() { $object = new \stdClass(); $this->viewHelper->expects($this->once())->method('renderChildren')->will($this->returnValue($object)); $this->mockPersistenceManager->expects($this->once())->method('getIdentifierByObject')->with($object)->will($this->returnValue('b59292c5-1a28-4b36-8615-10d3c5b3a4d8')); $this->assertEquals('b59292c5-1a28-4b36-8615-10d3c5b3a4d8', $this->viewHelper->render()); }
/** * @param BadgeAssertion $badgeAssertion * @return array */ public function badgeAssertionToArray(BadgeAssertion $badgeAssertion) { $badgeClassUri = $this->controllerContext->getUriBuilder()->reset()->setCreateAbsoluteUri(TRUE)->setFormat('json')->uriFor('show', array('badgeClass' => $badgeAssertion->getBadgeClass()), 'BadgeClass'); $badgeAssertionUri = $this->controllerContext->getUriBuilder()->reset()->setCreateAbsoluteUri(TRUE)->setFormat('json')->uriFor('show', array('badgeAssertion' => $badgeAssertion), 'BadgeAssertion'); $badgeAssertionIdentifier = $this->persistenceManager->getIdentifierByObject($badgeAssertion); return array('uid' => $badgeAssertionIdentifier, 'recipient' => $badgeAssertion->getIdentityObject(), 'badge' => $badgeClassUri, 'verify' => array('type' => 'hosted', 'url' => $badgeAssertionUri), 'issuedOn' => $badgeAssertion->getIssuedOn()->format('c')); }
/** * After returning advice, making sure we have an UUID for each and every entity. * * @param \TYPO3\Flow\Aop\JoinPointInterface $joinPoint The current join point * @return void * @Flow\Before("TYPO3\Flow\Persistence\Aspect\PersistenceMagicAspect->isEntity && method(.*->(__construct|__clone)()) && filter(TYPO3\Flow\Persistence\Doctrine\Mapping\Driver\FlowAnnotationDriver)") */ public function generateUuid(JoinPointInterface $joinPoint) { /** @var $proxy \TYPO3\Flow\Persistence\Aspect\PersistenceMagicInterface */ $proxy = $joinPoint->getProxy(); ObjectAccess::setProperty($proxy, 'Persistence_Object_Identifier', Algorithms::generateUUID(), TRUE); $this->persistenceManager->registerNewObject($proxy); }
/** */ public function getOptions() { $classSchema = $this->reflectionService->getClassSchema($this->getRelationClass()); if ($classSchema->getRepositoryClassName() !== NULL) { $repository = $this->objectManager->get($classSchema->getRepositoryClassName()); $query = call_user_func(array($repository, $this->settings['QueryMethod'])); } else { $query = $this->persistenceManager->createQueryForType($this->getRelationClass()); } $options = $query->execute()->toArray(); if ($this->settings['LabelPath'] !== NULL) { $options = array(); foreach ($query->execute() as $option) { $identifier = $this->persistenceManager->getIdentifierByObject($option); $label = ObjectAccess::getPropertyPath($option, $this->settings['LabelPath']); $options[$identifier] = $label; } } if ($this->settings['EmptyOption'] !== NULL) { $newOptions = array('' => $this->settings['EmptyOption']); foreach ($options as $key => $value) { $newOptions[$key] = $value; } $options = $newOptions; } return $options; }
/** * Gets the Party having an Account assigned * * @param Account $account * @return AbstractParty */ public function getAssignedPartyOfAccount(Account $account) { $accountIdentifier = $this->persistenceManager->getIdentifierByObject($account); if (isset($this->accountsInPartyRuntimeCache[$accountIdentifier])) { return $this->accountsInPartyRuntimeCache[$accountIdentifier]; } return $this->partyRepository->findOneHavingAccount($account); }
/** * Returns cache cache tag parts for the given object if known, otherwise NULL. * * @param $object * @return mixed */ public function identifyCacheTagForObject($object) { $className = get_class($object); if (property_exists($object, 'Persistence_Object_Identifier') || $this->reflectionService->isClassAnnotatedWith($className, Flow\Entity::class) || $this->reflectionService->isClassAnnotatedWith($className, Flow\ValueObject::class) || $this->reflectionService->isClassAnnotatedWith($className, Doctrine\Entity::class)) { $identifier = $this->persistenceManager->getIdentifierByObject($object); return $className . '_' . $identifier; } }
/** * @param NodeInterface $node The node that is currently edited (optional) * @param array $arguments Additional arguments (key / value) * @return array */ public function getData(NodeInterface $node, array $arguments) { $options = []; foreach ($this->userService->getUsers() as $user) { $options[$this->persistenceManager->getIdentifierByObject($user)] = ['label' => $user->getLabel()]; } return $options; }
/** * Get data * * @param NodeInterface $node unused * @param array $arguments unused * @return array title of all asset collections */ public function getData(NodeInterface $node = NULL, array $arguments) { $assetCollections = []; /** @var AssetCollection $assetCollection */ foreach ($this->assetCollectionRepository->findAll() as $assetCollection) { $assetCollections[] = ['value' => $this->persistenceManager->getIdentifierByObject($assetCollection), 'label' => $assetCollection->getTitle()]; } return $assetCollections; }
/** * @Flow\Around("method(TYPO3\Neos\Service\ContentElementWrappingService->getNodeProperty())") * @param JoinPointInterface $joinPoint */ public function getNodePropertyWithBadgeClass(JoinPointInterface $joinPoint) { $result = $joinPoint->getAdviceChain()->proceed($joinPoint); if ($result instanceof BadgeClass) { return json_encode($this->persistenceManager->getIdentifierByObject($result)); } else { return $result; } }
public function setAnimal($id) { $animal = $this->animalRepository->findByIdentifier($id); foreach ($animal->getTreatments() as $tr) { foreach ($tr->getTherapies() as $th) { $this->therapies[$this->persistenceManager->getIdentifierByObject($th)] = true; } } }
/** * @param NodeInterface|null $node * @param array $arguments * @return \TYPO3\Flow\Persistence\QueryResultInterface */ public function getData(NodeInterface $node = null, array $arguments) { $tagCollection = $this->tagRepository->findAll(); $tags = []; foreach ($tagCollection as $tag) { /** @var \TYPO3\Media\Domain\Model\Tag $tag */ $tags[$this->persistenceManager->getIdentifierByObject($tag)] = $tag; } return $tags; }
/** * @test * @return void */ public function generateUuidGeneratesUuidAndRegistersProxyAsNewObject() { $className = 'Class' . md5(uniqid(mt_rand(), TRUE)); eval('class ' . $className . ' implements \\TYPO3\\Flow\\Persistence\\Aspect\\PersistenceMagicInterface { public $Persistence_Object_Identifier = NULL; }'); $object = new $className(); $this->mockJoinPoint->expects($this->atLeastOnce())->method('getProxy')->will($this->returnValue($object)); $this->mockPersistenceManager->expects($this->atLeastOnce())->method('registerNewObject')->with($object); $this->persistenceMagicAspect->generateUuid($this->mockJoinPoint); $this->assertEquals(36, strlen($object->Persistence_Object_Identifier)); }
/** * Get data * * @param NodeInterface $node The node that is currently edited (optional) * @param array $arguments Additional arguments (key / value) * @return mixed JSON serializable data * @api */ public function getData(NodeInterface $node = NULL, array $arguments) { $result = array(); $result[''] = array('label' => 'Please select a receiver group'); foreach ($this->receiverGroupRepository->findAll() as $receiverGroup) { /* @var $receiverGroup \Sandstorm\Newsletter\Domain\Model\ReceiverGroup */ $result[$this->persistenceManager->getIdentifierByObject($receiverGroup)] = array('label' => $receiverGroup->getFullLabel()); } return $result; }
/** * @test */ public function getAssignedPartyOfAccountCachesParty() { $this->mockPersistenceManager->expects($this->any())->method('getIdentifierByObject')->will($this->returnValue('723e3913-f803-42c8-a44c-fd7115f555c3')); $this->mockPartyRepository->expects($this->once())->method('findOneHavingAccount')->with($this->account)->will($this->returnValue($this->party)); $this->party->addAccount($this->account); $assignedParty = $this->partyService->getAssignedPartyOfAccount($this->account); $this->assertSame($this->party, $assignedParty); $assignedParty = $this->partyService->getAssignedPartyOfAccount($this->account); $this->assertSame($this->party, $assignedParty); }
/** * Sets up this test case * */ public function setUp() { $this->mockObjectManager = $this->getMock(\TYPO3\Flow\Object\ObjectManagerInterface::class); $this->route = $this->getAccessibleMock(\TYPO3\Flow\Mvc\Routing\Route::class, array('dummy')); $this->route->_set('objectManager', $this->mockObjectManager); $this->mockPersistenceManager = $this->getMock(\TYPO3\Flow\Persistence\PersistenceManagerInterface::class); $this->mockPersistenceManager->expects($this->any())->method('convertObjectsToIdentityArrays')->will($this->returnCallback(function ($array) { return $array; })); $this->inject($this->route, 'persistenceManager', $this->mockPersistenceManager); }
/** * Get data * * @param NodeInterface $node The node that is currently edited (optional) * @param array $arguments Additional arguments (key / value) * @return array JSON serializable data */ public function getData(NodeInterface $node = NULL, array $arguments) { $collections = $this->instagramCollectionRepository->findAll(); /* @var \Weissheiten\Neos\InstagramMedia\Domain\Model\InstagramCollection $col */ foreach ($collections as $col) { /*$rv[] = array('value' => json_encode(array('__identity' => $this->persistenceManager->getIdentifierByObject($col), '__type' => '\Weissheiten\Neos\InstagramMedia\Domain\Model\InstagramCollection')),*/ $rv[] = array('value' => $this->persistenceManager->getIdentifierByObject($col), 'label' => $col->getTitle()); } return $rv; }
/** * Loads the objects this LazySplObjectStorage is supposed to hold. * * @return void */ protected function initialize() { if (is_array($this->objectIdentifiers)) { foreach ($this->objectIdentifiers as $identifier) { try { parent::attach($this->persistenceManager->getObjectByIdentifier($identifier)); } catch (\TYPO3\Flow\Persistence\Generic\Exception\InvalidObjectDataException $exception) { // when security query rewriting holds back an object here, we skip it... } } $this->objectIdentifiers = null; } }
/** * Outputs the identifier of the specified object * * @param object $value the object to render the identifier for, or NULL if VH children should be used * @return mixed the identifier of $value, usually the UUID * @throws ViewHelper\Exception if the given value is no object * @api */ public function render($value = NULL) { if ($value === NULL) { $value = $this->renderChildren(); } if ($value === NULL) { return NULL; } if (!is_object($value)) { throw new ViewHelper\Exception('f:format.identifier expects an object, ' . gettype($value) . ' given.', 1337700024); } return $this->persistenceManager->getIdentifierByObject($value); }
/** * Renders a hidden form field containing the technical identity of the given object. * * @param object $object Object to create the identity field for * @param string $name Name * @return string A hidden field containing the Identity (UUID in Flow) of the given object or NULL if the object is unknown to the persistence framework * @see \TYPO3\Flow\Mvc\Controller\Argument::setValue() */ protected function renderHiddenIdentityField($object, $name) { if (!is_object($object) || $this->persistenceManager->isNewObject($object)) { return ''; } $identifier = $this->persistenceManager->getIdentifierByObject($object); if ($identifier === null) { return chr(10) . '<!-- Object of type ' . get_class($object) . ' is without identity -->' . chr(10); } $name = $this->prefixFieldName($name) . '[__identity]'; $this->registerFieldNameForFormTokenGeneration($name); return chr(10) . '<input type="hidden" name="' . $name . '" value="' . $identifier . '" />' . chr(10); }
/** * @param \Lightwerk\SurfCaptain\Domain\Model\Deployment $surfCaptainDeployment * @param \TYPO3\Flow\Log\LoggerInterface $logger * @return Deployment * @throws Exception */ public function getDeploymentByDeploymentRecord(\Lightwerk\SurfCaptain\Domain\Model\Deployment $surfCaptainDeployment, LoggerInterface $logger) { $deployment = new Deployment($this->persistenceManager->getIdentifierByObject($surfCaptainDeployment)); $deployment->setLogger($logger); $configuration = $surfCaptainDeployment->getConfiguration(); if (empty($configuration['applications']) || !is_array($configuration['applications'])) { throw new Exception('No applications are given in deployment configuration', 1408397565); } $applications = $this->applicationFactory->getApplicationsByConfiguration($configuration['applications']); foreach ($applications as $application) { $deployment->addApplication($application); } return $deployment; }
/** * Appends the given message along with the additional information into the log. * * @param string $message The message to log * @param integer $severity One of the LOG_* constants * @param mixed $additionalData A variable containing more information about the event to be logged * @param string $packageKey Key of the package triggering the log (determined automatically if not specified) * @param string $className Name of the class triggering the log (determined automatically if not specified) * @param string $methodName Name of the method triggering the log (determined automatically if not specified) * @return void * @api */ public function append($message, $severity = LOG_INFO, $additionalData = NULL, $packageKey = NULL, $className = NULL, $methodName = NULL) { if ($this->number < self::MAX_LOGS) { $log = new Log(); $log->setDeployment($this->deployment)->setDate(new \DateTime())->setNumber(++$this->number)->setMessage($message)->setSeverity($severity); $this->logRepository->add($log); $this->persistenceManager->persistAll(); } elseif ($this->number === self::MAX_LOGS) { $log = new Log(); $log->setDeployment($this->deployment)->setDate(new \DateTime())->setNumber(++$this->number)->setMessage('logging killed with #logs > ' . self::MAX_LOGS)->setSeverity(LOG_EMERG); $this->logRepository->add($log); $this->persistenceManager->persistAll(); } }
/** * Sets up this test case * */ public function setUp() { $this->mockObjectManager = $this->getMock('TYPO3\\Flow\\Object\\ObjectManagerInterface'); $this->mockObjectManager->expects($this->any())->method('create')->will($this->returnCallback(array($this, 'objectManagerCallBack'))); $this->route = $this->getAccessibleMock('TYPO3\\Flow\\Mvc\\Routing\\Route', array('dummy')); $this->route->_set('objectManager', $this->mockObjectManager); $this->mockRouter = $this->getMock('TYPO3\\Flow\\Mvc\\Routing\\RouterInterface'); $this->mockRouter->expects($this->any())->method('getControllerObjectName')->will($this->returnValue('SomeControllerObjectName')); $this->inject($this->route, 'router', $this->mockRouter); $this->mockPersistenceManager = $this->getMock('TYPO3\\Flow\\Persistence\\PersistenceManagerInterface'); $this->mockPersistenceManager->expects($this->any())->method('convertObjectsToIdentityArrays')->will($this->returnCallback(function ($array) { return $array; })); $this->inject($this->route, 'persistenceManager', $this->mockPersistenceManager); }
/** * Sends the given HTTP request * * @param Http\Request $httpRequest * @return Http\Response * @throws Http\Exception * @api */ public function sendRequest(Http\Request $httpRequest) { $requestHandler = $this->bootstrap->getActiveRequestHandler(); if (!$requestHandler instanceof FunctionalTestRequestHandler) { throw new Http\Exception('The browser\'s internal request engine has only been designed for use within functional tests.', 1335523749); } $this->securityContext->clearContext(); $this->validatorResolver->reset(); $response = new Http\Response(); $requestHandler->setHttpRequest($httpRequest); $requestHandler->setHttpResponse($response); $objectManager = $this->bootstrap->getObjectManager(); $baseComponentChain = $objectManager->get(\TYPO3\Flow\Http\Component\ComponentChain::class); $componentContext = new ComponentContext($httpRequest, $response); if (version_compare(PHP_VERSION, '6.0.0') >= 0) { try { $baseComponentChain->handle($componentContext); } catch (\Throwable $throwable) { $this->prepareErrorResponse($throwable, $response); } } else { try { $baseComponentChain->handle($componentContext); } catch (\Exception $exception) { $this->prepareErrorResponse($exception, $response); } } $session = $this->bootstrap->getObjectManager()->get(\TYPO3\Flow\Session\SessionInterface::class); if ($session->isStarted()) { $session->close(); } $this->persistenceManager->clearState(); return $response; }
/** * Finds an object from the repository by searching for its identity properties. * * @param array $identityProperties Property names and values to search for * @param string $type The object type to look for * @return object Either the object matching the identity or NULL if no object was found * @throws DuplicateObjectException if more than one object was found */ protected function findObjectByIdentityProperties(array $identityProperties, $type) { $query = $this->persistenceManager->createQueryForType($type); $classSchema = $this->reflectionService->getClassSchema($type); $equals = array(); foreach ($classSchema->getIdentityProperties() as $propertyName => $propertyType) { if (isset($identityProperties[$propertyName])) { if ($propertyType === 'string') { $equals[] = $query->equals($propertyName, $identityProperties[$propertyName], FALSE); } else { $equals[] = $query->equals($propertyName, $identityProperties[$propertyName]); } } } if (count($equals) === 1) { $constraint = current($equals); } else { $constraint = $query->logicalAnd(current($equals), next($equals)); while (($equal = next($equals)) !== FALSE) { $constraint = $query->logicalAnd($constraint, $equal); } } $objects = $query->matching($constraint)->execute(); $numberOfResults = $objects->count(); if ($numberOfResults === 1) { return $objects->getFirst(); } elseif ($numberOfResults === 0) { return NULL; } else { throw new DuplicateObjectException('More than one object was returned for the given identity, this is a constraint violation.', 1259612399); } }
/** * After returning advice, generates the value hash for the object * * @param \TYPO3\Flow\Aop\JoinPointInterface $joinPoint The current join point * @return void * @Flow\After("classAnnotatedWith(TYPO3\Flow\Annotations\ValueObject) && method(.*->__construct()) && filter(TYPO3\Flow\Persistence\Doctrine\Mapping\Driver\FlowAnnotationDriver)") */ public function generateValueHash(JoinPointInterface $joinPoint) { $proxy = $joinPoint->getProxy(); $proxyClassName = get_class($proxy); $hashSourceParts = array(); $classSchema = $this->reflectionService->getClassSchema($proxyClassName); foreach ($classSchema->getProperties() as $property => $propertySchema) { // Currently, private properties are transient. Should this behaviour change, they need to be included // in the value hash generation if ($classSchema->isPropertyTransient($property) || $this->reflectionService->isPropertyPrivate($proxyClassName, $property)) { continue; } $propertyValue = ObjectAccess::getProperty($proxy, $property, true); if (is_object($propertyValue) === true) { // The persistence manager will return NULL if the given object is unknown to persistence $propertyValue = $this->persistenceManager->getIdentifierByObject($propertyValue) ?: $propertyValue; } $hashSourceParts[$property] = $propertyValue; } ksort($hashSourceParts); $hashSourceParts['__class_name__'] = $proxyClassName; $serializedSource = $this->useIgBinary === true ? igbinary_serialize($hashSourceParts) : serialize($hashSourceParts); $proxy = $joinPoint->getProxy(); ObjectAccess::setProperty($proxy, 'Persistence_Object_Identifier', sha1($serializedSource), true); }