/**
* 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);
}
/**
* Upload a new image, and return its metadata.
*
* Depending on the $metadata argument it will return asset metadata for the AssetEditor
* or image metadata for the ImageEditor
*
* @param Asset $asset
* @param string $metadata Type of metadata to return ("Asset" or "Image")
* @return string
*/
public function uploadAssetAction(Asset $asset, $metadata)
{
$this->response->setHeader('Content-Type', 'application/json');
/** @var Site $currentSite */
$currentSite = $this->siteRepository->findOneByNodeName($this->request->getInternalArgument('__siteNodeName'));
if ($currentSite !== NULL && $currentSite->getAssetCollection() !== NULL) {
$currentSite->getAssetCollection()->addAsset($asset);
$this->assetCollectionRepository->update($currentSite->getAssetCollection());
}
switch ($metadata) {
case 'Asset':
$result = $this->getAssetProperties($asset);
if ($this->persistenceManager->isNewObject($asset)) {
$this->assetRepository->add($asset);
}
break;
case 'Image':
$result = $this->getImageInterfacePreviewData($asset);
if ($this->persistenceManager->isNewObject($asset)) {
$this->imageRepository->add($asset);
}
break;
default:
$this->response->setStatus(400);
$result = array('error' => 'Invalid "metadata" type: ' . $metadata);
}
return json_encode($result);
}
/**
* @param object $object
* @param string $parentIdentifier
* @return array
*/
protected function processObject($object, $parentIdentifier)
{
if (isset($this->classSchemata[get_class($object)]) && $this->classSchemata[get_class($object)]->isAggregateRoot() && !$this->persistenceManager->isNewObject($object)) {
return array('identifier' => $this->persistenceSession->getIdentifierByObject($object));
} else {
return array('identifier' => $this->persistObject($object, $parentIdentifier));
}
}
/**
* Checks if recently imported resources really have been persisted - and if not, removes its data from the
* respective storage.
*
* @return void
*/
public function shutdownObject()
{
foreach ($this->resourceRepository->getAddedResources() as $resource) {
if ($this->persistenceManager->isNewObject($resource)) {
$this->deleteResource($resource, FALSE);
}
}
}
/**
* Refreshes a thumbnail and persists the thumbnail
*
* @param Thumbnail $thumbnail
* @return void
*/
public function refreshThumbnail(Thumbnail $thumbnail)
{
$thumbnail->refresh();
$this->persistenceManager->whiteListObject($thumbnail);
if (!$this->persistenceManager->isNewObject($thumbnail)) {
$this->thumbnailRepository->update($thumbnail);
}
}
/**
* Generate a new image variant from given data.
*
* @param ImageVariant $asset
* @return string
*/
public function createImageVariantAction(ImageVariant $asset)
{
if ($this->persistenceManager->isNewObject($asset)) {
$this->assetRepository->add($asset);
}
$propertyMappingConfiguration = new PropertyMappingConfiguration();
// This will not be sent as "application/json" as we need the JSON string and not the single variables.
return json_encode($this->entityToIdentityConverter->convertFrom($asset, 'array', [], $propertyMappingConfiguration));
}
/**
* Checks if a propertyValue contains an entity and persists it.
*
* @param mixed $propertyValue
* @return void
*/
protected function persistEntities($propertyValue)
{
if (!$propertyValue instanceof \Iterator && !is_array($propertyValue)) {
$propertyValue = array($propertyValue);
}
foreach ($propertyValue as $possibleEntity) {
if (is_object($possibleEntity) && $possibleEntity instanceof \TYPO3\Flow\Persistence\Aspect\PersistenceMagicInterface) {
$this->persistenceManager->isNewObject($possibleEntity) ? $this->persistenceManager->add($possibleEntity) : $this->persistenceManager->update($possibleEntity);
// TODO: Needed because the originalAsset will not cascade persist. We should find a generic solution to this.
if ($possibleEntity instanceof ImageVariant) {
$asset = $possibleEntity->getOriginalAsset();
$this->persistenceManager->isNewObject($asset) ? $this->persistenceManager->add($asset) : $this->persistenceManager->update($asset);
}
}
}
}
/**
* Traverses the $array and replaces known persisted objects with a tuple of
* type and identifier.
*
* @param array $array
* @return void
* @throws \RuntimeException
*/
protected function encodeObjectReferences(array &$array)
{
foreach ($array as &$value) {
if (!is_object($value) || is_object($value) && $value instanceof \TYPO3\Flow\Object\DependencyInjection\DependencyProxy) {
continue;
}
$propertyClassName = get_class($value);
if ($value instanceof \SplObjectStorage) {
throw new \RuntimeException('SplObjectStorage in array properties is not supported', 1375196580);
} elseif ($value instanceof \Doctrine\Common\Collections\Collection) {
throw new \RuntimeException('Collection in array properties is not supported', 1375196581);
} elseif ($value instanceof \ArrayObject) {
throw new \RuntimeException('ArrayObject in array properties is not supported', 1375196582);
} elseif ($this->persistenceManager->isNewObject($value) === FALSE && ($this->reflectionService->isClassAnnotatedWith($propertyClassName, 'TYPO3\\Flow\\Annotations\\Entity') || $this->reflectionService->isClassAnnotatedWith($propertyClassName, 'TYPO3\\Flow\\Annotations\\ValueObject') || $this->reflectionService->isClassAnnotatedWith($propertyClassName, 'Doctrine\\ORM\\Mapping\\Entity'))) {
$value = array('__flow_object_type' => $propertyClassName, '__identifier' => $this->persistenceManager->getIdentifierByObject($value));
}
}
}
/**
* Traverses the $array and replaces known persisted objects with a tuple of
* type and identifier.
*
* @param array $array
* @return void
* @throws \RuntimeException
*/
protected function encodeObjectReferences(array &$array)
{
foreach ($array as &$value) {
if (is_array($value)) {
$this->encodeObjectReferences($value);
}
if (!is_object($value) || is_object($value) && $value instanceof DependencyProxy) {
continue;
}
$propertyClassName = TypeHandling::getTypeForValue($value);
if ($value instanceof \SplObjectStorage) {
throw new \RuntimeException('SplObjectStorage in array properties is not supported', 1375196580);
} elseif ($value instanceof \Doctrine\Common\Collections\Collection) {
throw new \RuntimeException('Collection in array properties is not supported', 1375196581);
} elseif ($value instanceof \ArrayObject) {
throw new \RuntimeException('ArrayObject in array properties is not supported', 1375196582);
} elseif ($this->persistenceManager->isNewObject($value) === false && ($this->reflectionService->isClassAnnotatedWith($propertyClassName, Flow\Entity::class) || $this->reflectionService->isClassAnnotatedWith($propertyClassName, Flow\ValueObject::class) || $this->reflectionService->isClassAnnotatedWith($propertyClassName, \Doctrine\ORM\Mapping\Entity::class))) {
$value = ['__flow_object_type' => $propertyClassName, '__identifier' => $this->persistenceManager->getIdentifierByObject($value)];
}
}
}
/**
* Returns a thumbnail of the given asset
*
* If the maximum width / height is not specified or exceeds the original asset's dimensions, the width / height of
* the original asset is used.
*
* @param AssetInterface $asset The asset to render a thumbnail for
* @param ThumbnailConfiguration $configuration
* @return Thumbnail
* @throws \Exception
*/
public function getThumbnail(AssetInterface $asset, ThumbnailConfiguration $configuration)
{
$assetIdentifier = $this->persistenceManager->getIdentifierByObject($asset);
$configurationHash = $configuration->getHash();
if (!isset($this->thumbnailCache[$assetIdentifier])) {
$this->thumbnailCache[$assetIdentifier] = [];
}
if (isset($this->thumbnailCache[$assetIdentifier][$configurationHash])) {
$thumbnail = $this->thumbnailCache[$assetIdentifier][$configurationHash];
} else {
$thumbnail = $this->thumbnailRepository->findOneByAssetAndThumbnailConfiguration($asset, $configuration);
$this->thumbnailCache[$assetIdentifier][$configurationHash] = $thumbnail;
}
$async = $configuration->isAsync();
if ($thumbnail === null) {
try {
$thumbnail = new Thumbnail($asset, $configuration, $async);
// If the thumbnail strategy failed to generate a valid thumbnail
if ($async === false && $thumbnail->getResource() === null && $thumbnail->getStaticResource() === null) {
$this->thumbnailRepository->remove($thumbnail);
return null;
}
if (!$this->persistenceManager->isNewObject($asset)) {
$this->thumbnailRepository->add($thumbnail);
}
$asset->addThumbnail($thumbnail);
// Allow thumbnails to be persisted even if this is a "safe" HTTP request:
$this->persistenceManager->whiteListObject($thumbnail);
$this->thumbnailCache[$assetIdentifier][$configurationHash] = $thumbnail;
} catch (NoThumbnailAvailableException $exception) {
$this->systemLogger->logException($exception);
return null;
}
$this->persistenceManager->whiteListObject($thumbnail);
$this->thumbnailCache[$assetIdentifier][$configurationHash] = $thumbnail;
} elseif ($thumbnail->getResource() === null && $async === false) {
$this->refreshThumbnail($thumbnail);
}
return $thumbnail;
}
/**
* Sets the given $nodePropertyXml on the $node instance
*
* @param \SimpleXMLElement $nodePropertyXml
* @param NodeInterface $node
* @return void
*/
protected function importNodeProperty(\SimpleXMLElement $nodePropertyXml, NodeInterface $node)
{
if (!isset($nodePropertyXml['__type'])) {
$node->setProperty($nodePropertyXml->getName(), (string) $nodePropertyXml);
return;
}
switch ($nodePropertyXml['__type']) {
case 'boolean':
$node->setProperty($nodePropertyXml->getName(), (string) $nodePropertyXml === '1');
break;
case 'reference':
$targetIdentifier = (string) $nodePropertyXml->node['identifier'] === '' ? null : (string) $nodePropertyXml->node['identifier'];
$node->setProperty($nodePropertyXml->getName(), $targetIdentifier);
break;
case 'references':
$referencedNodeIdentifiers = array();
foreach ($nodePropertyXml->node as $referenceNodeXml) {
if ((string) $referenceNodeXml['identifier'] !== '') {
$referencedNodeIdentifiers[] = (string) $referenceNodeXml['identifier'];
}
}
$node->setProperty($nodePropertyXml->getName(), $referencedNodeIdentifiers);
break;
case 'array':
$entries = array();
foreach ($nodePropertyXml->children() as $childNodeXml) {
$entry = null;
if (!isset($childNodeXml['__classname']) || !in_array($childNodeXml['__classname'], array('TYPO3\\Media\\Domain\\Model\\Image', 'TYPO3\\Media\\Domain\\Model\\Asset'))) {
// Only arrays of asset objects are supported now
continue;
}
$entryClassName = (string) $childNodeXml['__classname'];
if (isset($childNodeXml['__identifier'])) {
if ($entryClassName === 'TYPO3\\Media\\Domain\\Model\\Image') {
$entry = $this->imageRepository->findByIdentifier((string) $childNodeXml['__identifier']);
} else {
$entry = $this->assetRepository->findByIdentifier((string) $childNodeXml['__identifier']);
}
}
if ($entry === null) {
$resourceXml = $childNodeXml->xpath('resource');
$resourceHash = $resourceXml[0]->xpath('hash');
$content = $resourceXml[0]->xpath('content');
$filename = $resourceXml[0]->xpath('filename');
$resource = $this->importResource(!empty($filename) ? (string) $filename[0] : null, !empty($resourceHash) ? (string) $resourceHash[0] : null, !empty($content) ? (string) $content[0] : null, isset($resourceXml[0]['__identifier']) ? (string) $resourceXml[0]['__identifier'] : null);
$entry = new $entryClassName($resource);
if (isset($childNodeXml['__identifier'])) {
ObjectAccess::setProperty($entry, 'Persistence_Object_Identifier', (string) $childNodeXml['__identifier'], true);
}
}
$propertiesXml = $childNodeXml->xpath('properties/*');
foreach ($propertiesXml as $propertyXml) {
if (!isset($propertyXml['__type'])) {
ObjectAccess::setProperty($entry, $propertyXml->getName(), (string) $propertyXml);
continue;
}
switch ($propertyXml['__type']) {
case 'boolean':
ObjectAccess::setProperty($entry, $propertyXml->getName(), (bool) $propertyXml);
break;
case 'string':
ObjectAccess::setProperty($entry, $propertyXml->getName(), (string) $propertyXml);
break;
case 'object':
ObjectAccess::setProperty($entry, $propertyXml->getName(), $this->xmlToObject($propertyXml));
}
}
/**
* During the persist Doctrine calls the serialize() method on the asset for the ObjectArray
* object, during this serialize the resource property gets lost.
* The AssetList node type has a custom implementation to work around this bug.
* @see NEOS-121
*/
$repositoryAction = $this->persistenceManager->isNewObject($entry) ? 'add' : 'update';
if ($entry instanceof Image) {
$this->imageRepository->{$repositoryAction}($entry);
} else {
$this->assetRepository->{$repositoryAction}($entry);
}
$entries[] = $entry;
}
$node->setProperty($nodePropertyXml->getName(), $entries);
break;
case 'object':
$node->setProperty($nodePropertyXml->getName(), $this->xmlToObject($nodePropertyXml));
break;
}
}
/**
* Checks if a property value contains an entity and persists it.
*
* @param mixed $value
*/
protected function persistRelatedEntities($value)
{
if (!is_array($value) && !$value instanceof \Iterator) {
$value = array($value);
}
foreach ($value as $element) {
if (is_object($element) && $element instanceof PersistenceMagicInterface) {
$this->persistenceManager->isNewObject($element) ? $this->persistenceManager->add($element) : $this->persistenceManager->update($element);
}
}
}
/**
* @param \DLigo\Animaltool\Domain\Model\Animal $animal
* @param array $treatment
* @param string $tag
* @param string $passId
* @param string $contunue
* @param string $release
* @param string $extern
* @param string $newextern
* @param string $dead
* @param string $origRFID
* @param string $origEarTag
* @Flow\Validate (argumentName="$treatment", type="\DLigo\Animaltool\Validation\Validator\TreatmentValidator")
* @Flow\Validate (argumentName="$animal.healthCondition",type="NotEmpty")
* @Flow\Validate (argumentName="$animal.photo", type="NotEmpty")
* @return void
*/
public function treatAction(Animal $animal, $treatment, $tag = '', $passId = '', $continue = null, $release = null, $extern = null, $newextern = null, $dead = null, $origRFID = '', $origEarTag = '')
{
$duplicate = false;
// \TYPO3\Flow\var_dump($this->request);
$done = false;
$mergeMessage = '';
$merge = '';
$tr = $animal->getOpenTreatment();
if (!$tr) {
$tr = new \DLigo\Animaltool\Domain\Model\Treatment();
$tr->setStartDate(new \DateTime('now'));
$tr->setAnimal($animal);
// $tr->setDoctor($this->session->getUser());
$animal->getTreatments()->add($tr);
}
$did = isset($treatment['doctor']['__identity']) ? $treatment['doctor']['__identity'] : $treatment['doctor'];
$tr->setDoctor($this->userRepository->findByIdentifier($did));
$therapies = new \Doctrine\Common\Collections\ArrayCollection();
$extras = new \Doctrine\Common\Collections\ArrayCollection();
if (is_array($treatment['therapies'])) {
foreach ($treatment['therapies'] as $thid) {
$therapy = $this->therapyRepository->findByIdentifier($thid);
if ($therapy->getHasExtraData()) {
$extra = $this->treatmentExtraRepository->findByTherapyAndTreatment($thid, $tr)->getFirst();
if (!$extra) {
$extra = new \DLigo\Animaltool\Domain\Model\TreatmentExtra();
$extra->setTreatment($tr);
$extra->setTherapy($therapy);
}
$extra->setValue($treatment['treatmentExtra'][$thid]);
unset($treatment['treatmentExtra'][$thid]);
$extras->add($extra);
}
$therapies->add($therapy);
}
}
$tr->setTherapies($therapies);
$tr->setTreatmentExtras($extras);
$tr->setComment($treatment['comment']);
if ($this->persistenceManager->isNewObject($tr)) {
$this->treatmentRepository->add($tr);
} else {
$this->treatmentRepository->update($tr);
}
if (isset($treatment['treatmentExtra']) && is_array($treatment['treatmentExtra'])) {
foreach ($treatment['treatmentExtra'] as $thid => $value) {
$extra = $this->treatmentExtraRepository->findByTherapyAndTreatment($thid, $tr)->getFirst();
if ($extra != null) {
$this->treatmentExtraRepository->remove($extra);
}
}
}
if ($continue) {
$animal->setStayStatus(Animal::THERAPY);
$animal->setTherapyStatus(Animal::OPERATION);
$animal->stopOpenExternals();
$animal->stopOpenTreatments();
} elseif ($release) {
$animal->setStayStatus(Animal::RELEASING);
$animal->setTherapyStatus(Animal::READY);
$animal->stopOpenExternals();
$animal->stopOpenTreatments();
$animal->getLastAction()->setReleaseDate(new \DateTime('now'));
} elseif ($extern) {
if ($animal->getStayStatus() == Animal::CATCHED) {
$animal->setStayStatus(Animal::THERAPY);
}
if ($animal->getTherapyStatus() == Animal::WAIT) {
$animal->setTherapyStatus(Animal::OPERATION);
}
$animal->stopOpenTreatments();
} elseif ($newextern) {
$animal->stopOpenExternals();
$animal->stopOpenTreatments();
} elseif ($dead) {
$animal->setStayStatus(Animal::RELEASED);
$animal->setTherapyStatus(Animal::DEAD);
$animal->stopOpenExternals();
$animal->stopOpenTreatments();
}
$oldAnimal = null;
if ($animal->getIsPrivate()) {
$animal->setRFID($tag);
if ($tag != $origRFID && !empty($tag)) {
$oldAnimal = $this->animalRepository->findByRFID($tag)->getFirst();
}
$animal->getOwner()->setPassId($passId);
} else {
$animal->setEarTag($tag);
if ($tag != $origEarTag && !empty($tag)) {
$oldAnimal = $this->animalRepository->findByEarTag($tag)->getFirst();
}
}
if (!empty($oldAnimal)) {
$tag = "_DUMMY_" . $tag . "_" . time();
$duplicate = true;
$animal->setIsDummy(true);
$animal->setRFID($tag);
}
$this->animalRepository->update($animal);
if ($duplicate) {
$this->redirect('duplicate', null, null, array('animal' => $animal, 'oldAnimal' => $oldAnimal, 'external' => $extern != null));
}
if ($extern || $newextern) {
$this->redirect('open', 'External', null, array('animal' => $animal));
}
$this->addFlashMessage('Updated the animal.' . $mergeMessage, '', \TYPO3\Flow\Error\Message::SEVERITY_OK, array(), 'flash.animal.update' . $merge);
$this->redirect('index');
return '';
}
/**
* Serializes an object as property array.
*
* @param object $object The object to store in the registry
* @param boolean $isTopLevelItem Internal flag for managing the recursion
* @return array The property array
*/
public function serializeObjectAsPropertyArray($object, $isTopLevelItem = true)
{
if ($isTopLevelItem) {
$this->objectReferences = new \SplObjectStorage();
}
$this->objectReferences->attach($object);
$className = get_class($object);
$propertyArray = array();
foreach ($this->reflectionService->getClassPropertyNames($className) as $propertyName) {
if ($this->reflectionService->isPropertyTaggedWith($className, $propertyName, 'transient')) {
continue;
}
$propertyReflection = new \TYPO3\Flow\Reflection\PropertyReflection($className, $propertyName);
$propertyValue = $propertyReflection->getValue($object);
if (is_object($propertyValue) && $propertyValue instanceof \TYPO3\Flow\Object\DependencyInjection\DependencyProxy) {
continue;
}
if (is_object($propertyValue) && isset($this->objectReferences[$propertyValue])) {
$propertyArray[$propertyName][self::TYPE] = 'object';
$propertyArray[$propertyName][self::VALUE] = \spl_object_hash($propertyValue);
continue;
}
$propertyClassName = is_object($propertyValue) ? get_class($propertyValue) : '';
if ($propertyClassName === 'SplObjectStorage') {
$propertyArray[$propertyName][self::TYPE] = 'SplObjectStorage';
$propertyArray[$propertyName][self::VALUE] = array();
foreach ($propertyValue as $storedObject) {
$propertyArray[$propertyName][self::VALUE][] = spl_object_hash($storedObject);
$this->serializeObjectAsPropertyArray($storedObject, false);
}
} elseif (is_object($propertyValue) && $propertyValue instanceof \Doctrine\Common\Collections\Collection) {
$propertyArray[$propertyName][self::TYPE] = 'Collection';
$propertyArray[$propertyName][self::CLASSNAME] = get_class($propertyValue);
foreach ($propertyValue as $storedObject) {
$propertyArray[$propertyName][self::VALUE][] = spl_object_hash($storedObject);
$this->serializeObjectAsPropertyArray($storedObject, false);
}
} elseif (is_object($propertyValue) && $propertyValue instanceof \ArrayObject) {
$propertyArray[$propertyName][self::TYPE] = 'ArrayObject';
$propertyArray[$propertyName][self::VALUE] = $this->buildStorageArrayForArrayProperty($propertyValue->getArrayCopy());
} elseif (is_object($propertyValue) && $this->persistenceManager->isNewObject($propertyValue) === false && ($this->reflectionService->isClassAnnotatedWith($propertyClassName, \TYPO3\Flow\Annotations\Entity::class) || $this->reflectionService->isClassAnnotatedWith($propertyClassName, \TYPO3\Flow\Annotations\ValueObject::class) || $this->reflectionService->isClassAnnotatedWith($propertyClassName, 'Doctrine\\ORM\\Mapping\\Entity'))) {
$propertyArray[$propertyName][self::TYPE] = 'persistenceObject';
$propertyArray[$propertyName][self::VALUE] = get_class($propertyValue) . ':' . $this->persistenceManager->getIdentifierByObject($propertyValue);
} elseif (is_object($propertyValue)) {
$propertyObjectName = $this->objectManager->getObjectNameByClassName($propertyClassName);
if ($this->objectManager->getScope($propertyObjectName) === \TYPO3\Flow\Object\Configuration\Configuration::SCOPE_SINGLETON) {
continue;
}
$propertyArray[$propertyName][self::TYPE] = 'object';
$propertyArray[$propertyName][self::VALUE] = spl_object_hash($propertyValue);
$this->serializeObjectAsPropertyArray($propertyValue, false);
} elseif (is_array($propertyValue)) {
$propertyArray[$propertyName][self::TYPE] = 'array';
$propertyArray[$propertyName][self::VALUE] = $this->buildStorageArrayForArrayProperty($propertyValue);
} else {
$propertyArray[$propertyName][self::TYPE] = 'simple';
$propertyArray[$propertyName][self::VALUE] = $propertyValue;
}
}
$this->objectsAsArray[spl_object_hash($object)] = array(self::CLASSNAME => $className, self::PROPERTIES => $propertyArray);
if ($isTopLevelItem) {
return $this->objectsAsArray;
}
}
public function assertUnpersisted($entity)
{
$this->test->assertTrue($this->persistenceManager->isNewObject($entity), 'The Entity of type ' . get_class($entity) . ' is still persisted.');
return $this;
}
