/**
* @param Locale $locale
* @param Language $language
* @return string
*/
public function getLanguageLocalizedName(Locale $locale, Language $language)
{
$cacheIdentifier = 'language-labels-' . $locale->getLanguage();
$labelsFromCache = $this->languageCache->get($cacheIdentifier);
if ($labelsFromCache) {
return $labelsFromCache[$language->getKey()];
}
try {
$raw = $this->cldrRepository->getModelForLocale($locale)->getRawArray('localeDisplayNames/languages');
} catch (\Exception $e) {
return 'Problem reading data for ' . $language->getKey();
}
$languages = $this->getLanguages();
$labels = array();
/** @var Language $currentLanguage */
foreach ($languages as $currentLanguage) {
try {
$key = 'language[@type="' . $currentLanguage->getKey() . '"]';
if (is_array($raw)) {
if (array_key_exists($key, $raw)) {
$labels[$currentLanguage->getKey()] = $raw[$key];
} else {
$labels[$currentLanguage->getKey()] = $currentLanguage->getName();
}
} else {
$labels[$currentLanguage->getKey()] = 'Nothing found for ' . $currentLanguage->getKey();
}
} catch (\Exception $e) {
// not found
// $labels[$key] = 'Nothing found for ' . $language->getKey();
}
}
$this->languageCache->set($cacheIdentifier, $labels);
return $labels[$language->getKey()];
}
/**
* Return the json array for a given locale, sourceCatalog, xliffPath and package.
* The json will be cached.
*
* @param Locale $locale The locale
* @throws \TYPO3\Flow\I18n\Exception
* @return \TYPO3\Flow\Error\Result
*/
public function getCachedJson(Locale $locale)
{
$cacheIdentifier = md5($locale);
if ($this->xliffToJsonTranslationsCache->has($cacheIdentifier)) {
$json = $this->xliffToJsonTranslationsCache->get($cacheIdentifier);
} else {
$labels = [];
$localeChain = $this->localizationService->getLocaleChain($locale);
foreach ($this->packagesRegisteredForAutoInclusion as $packageKey => $sourcesToBeIncluded) {
if (!is_array($sourcesToBeIncluded)) {
continue;
}
$translationBasePath = Files::concatenatePaths([$this->packageManager->getPackage($packageKey)->getResourcesPath(), $this->xliffBasePath]);
// We merge labels in the chain from the worst choice to best choice
foreach (array_reverse($localeChain) as $allowedLocale) {
$localeSourcePath = Files::getNormalizedPath(Files::concatenatePaths([$translationBasePath, $allowedLocale]));
foreach ($sourcesToBeIncluded as $sourceName) {
foreach (glob($localeSourcePath . $sourceName . '.xlf') as $xliffPathAndFilename) {
$xliffPathInfo = pathinfo($xliffPathAndFilename);
$sourceName = str_replace($localeSourcePath, '', $xliffPathInfo['dirname'] . '/' . $xliffPathInfo['filename']);
$labels = Arrays::arrayMergeRecursiveOverrule($labels, $this->parseXliffToArray($xliffPathAndFilename, $packageKey, $sourceName));
}
}
}
}
$json = json_encode($labels);
$this->xliffToJsonTranslationsCache->set($cacheIdentifier, $json);
}
return $json;
}
/**
* This method walks through the view configuration and applies
* matching configurations in the order of their specifity score.
* Possible options are currently the viewObjectName to specify
* a different class that will be used to create the view and
* an array of options that will be set on the view object.
*
* @param \TYPO3\Flow\Mvc\ActionRequest $request
* @return array
*/
public function getViewConfiguration(ActionRequest $request)
{
$cacheIdentifier = $this->createCacheIdentifier($request);
$viewConfiguration = $this->cache->get($cacheIdentifier);
if ($viewConfiguration === false) {
$configurations = $this->configurationManager->getConfiguration('Views');
$requestMatcher = new RequestMatcher($request);
$context = new Context($requestMatcher);
$matchingConfigurations = array();
foreach ($configurations as $order => $configuration) {
$requestMatcher->resetWeight();
if (!isset($configuration['requestFilter'])) {
$matchingConfigurations[$order]['configuration'] = $configuration;
$matchingConfigurations[$order]['weight'] = $order;
} else {
$result = $this->eelEvaluator->evaluate($configuration['requestFilter'], $context);
if ($result === false) {
continue;
}
$matchingConfigurations[$order]['configuration'] = $configuration;
$matchingConfigurations[$order]['weight'] = $requestMatcher->getWeight() + $order;
}
}
usort($matchingConfigurations, function ($configuration1, $configuration2) {
return $configuration1['weight'] > $configuration2['weight'];
});
$viewConfiguration = array();
foreach ($matchingConfigurations as $key => $matchingConfiguration) {
$viewConfiguration = Arrays::arrayMergeRecursiveOverrule($viewConfiguration, $matchingConfiguration['configuration']);
}
$this->cache->set($cacheIdentifier, $viewConfiguration);
}
return $viewConfiguration;
}
/**
* Checks the cache for the route path given in the Request and returns the result
*
* @param Request $httpRequest
* @return array|boolean the cached route values or FALSE if no cache entry was found
*/
public function getCachedMatchResults(Request $httpRequest)
{
$cachedResult = $this->routeCache->get($this->buildRouteCacheIdentifier($httpRequest));
if ($cachedResult !== FALSE) {
$this->systemLogger->log(sprintf('Router route(): A cached Route with the cache identifier "%s" matched the path "%s".', $this->buildRouteCacheIdentifier($httpRequest), $httpRequest->getRelativePath()), LOG_DEBUG);
}
return $cachedResult;
}
/**
* Initialize the object and load caches
*/
public function initializeObject()
{
if (!$this->cache->get('systemNodeIdentifiers')) {
$this->initializeSystemNodes();
} else {
$this->systemNodeIdentifiers = $this->cache->get('systemNodeIdentifiers');
}
}
/**
* Lifecycle method, called after all dependencies have been injected.
* Here, the typeConverter array gets initialized.
*
* @return void
* @throws Exception\DuplicateTypeConverterException
*/
public function initializeObject()
{
if ($this->cache->has('typeConverterMap')) {
$this->typeConverters = $this->cache->get('typeConverterMap');
return;
}
$this->typeConverters = $this->prepareTypeConverterMap();
$this->cache->set('typeConverterMap', $this->typeConverters);
}
/**
* @param string $cacheKey
*
* @return mixed
*/
protected function getItem($cacheKey)
{
if (array_key_exists($cacheKey, $this->objectCache)) {
return $this->objectCache[$cacheKey];
}
$item = $this->apiCache->get($cacheKey);
$this->objectCache[$cacheKey] = $item;
return $item;
}
/**
* Initializes the locale service
*
* @return void
*/
public function initializeObject()
{
$this->configuration = new Configuration($this->settings['defaultLocale']);
$this->configuration->setFallbackRule($this->settings['fallbackRule']);
if ($this->cache->has('availableLocales')) {
$this->localeCollection = $this->cache->get('availableLocales');
} else {
$this->generateAvailableLocalesCollectionByScanningFilesystem();
$this->cache->set('availableLocales', $this->localeCollection);
}
}
/**
* @Flow\Around("setting(TYPO3.Neos.typoScript.enableObjectTreeCache) && method(TYPO3\Neos\Domain\Service\TypoScriptService->getMergedTypoScriptObjectTree())")
* @param \TYPO3\Flow\Aop\JoinPointInterface $joinPoint The current join point
* @return mixed
*/
public function cacheGetMergedTypoScriptObjectTree(JoinPointInterface $joinPoint)
{
$currentSiteNode = $joinPoint->getMethodArgument('startNode');
$cacheIdentifier = str_replace('.', '_', $currentSiteNode->getContext()->getCurrentSite()->getSiteResourcesPackageKey());
if ($this->typoScriptCache->has($cacheIdentifier)) {
$typoScriptObjectTree = $this->typoScriptCache->get($cacheIdentifier);
} else {
$typoScriptObjectTree = $joinPoint->getAdviceChain()->proceed($joinPoint);
$this->typoScriptCache->set($cacheIdentifier, $typoScriptObjectTree);
}
return $typoScriptObjectTree;
}
/**
* Returns the specified session. If no session with the given identifier exists,
* NULL is returned.
*
* @param string $sessionIdentifier The session identifier
* @return \TYPO3\Flow\Session\Session
* @api
*/
public function getSession($sessionIdentifier)
{
if ($this->currentSession !== NULL && $this->currentSession->isStarted() && $this->currentSession->getId() === $sessionIdentifier) {
return $this->currentSession;
}
if (isset($this->remoteSessions[$sessionIdentifier])) {
return $this->remoteSessions[$sessionIdentifier];
}
if ($this->metaDataCache->has($sessionIdentifier)) {
$sessionInfo = $this->metaDataCache->get($sessionIdentifier);
$this->remoteSessions[$sessionIdentifier] = new Session($sessionIdentifier, $sessionInfo['storageIdentifier'], $sessionInfo['lastActivityTimestamp'], $sessionInfo['tags']);
return $this->remoteSessions[$sessionIdentifier];
}
}
/**
* @Flow\Around("setting(Ttree.Embedly.logApiRequest) && within(Ttree\Embedly\Embedly) && method(public .*->(oembed|preview|objectify|extract|services)())")
* @param JoinPointInterface $joinPoint The current join point
* @return mixed
*/
public function getResponseFromCache(JoinPointInterface $joinPoint)
{
$proxy = $joinPoint->getProxy();
$key = ObjectAccess::getProperty($proxy, 'key');
$params = $joinPoint->getMethodArgument('params');
$cacheKey = md5($joinPoint->getClassName() . $joinPoint->getMethodName() . $key . json_encode($params));
if ($this->responseCache->has($cacheKey)) {
$this->systemLogger->log(sprintf(' cache hit Embedly::%s', $joinPoint->getMethodName()), LOG_DEBUG);
return $this->responseCache->get($cacheKey);
} else {
$this->systemLogger->log(sprintf(' cache miss Embedly::%s', $joinPoint->getMethodName()), LOG_DEBUG);
}
$response = $joinPoint->getAdviceChain()->proceed($joinPoint);
$this->responseCache->set($cacheKey, $response);
return $response;
}
/**
* Returns the data associated with the given key.
*
* @param string $key An identifier for the content stored in the session.
* @return mixed The contents associated with the given key
* @throws \TYPO3\Flow\Session\Exception\SessionNotStartedException
*/
public function getData($key)
{
if ($this->started !== true) {
throw new \TYPO3\Flow\Session\Exception\SessionNotStartedException('Tried to get session data, but the session has not been started yet.', 1351162255);
}
return $this->storageCache->get($this->storageIdentifier . md5($key));
}
/**
* Constructs the reader, loading parsed data from cache if available.
*
* @return void
*/
public function initializeObject()
{
if ($this->cache->has('parsedFormats') && $this->cache->has('parsedFormatsIndices') && $this->cache->has('localizedLiterals')) {
$this->parsedFormats = $this->cache->get('parsedFormats');
$this->parsedFormatsIndices = $this->cache->get('parsedFormatsIndices');
$this->localizedLiterals = $this->cache->get('localizedLiterals');
}
}
/**
* @return integer The current cache version identifier
*/
public function getCacheVersion()
{
$version = $this->xliffToJsonTranslationsCache->get('ConfigurationVersion');
if ($version === false) {
$version = time();
$this->xliffToJsonTranslationsCache->set('ConfigurationVersion', (string) $version);
}
return $version;
}
/**
* When it's called, XML file is parsed (using parser set in $xmlParser)
* or cache is loaded, if available.
*
* @return void
*/
public function initializeObject()
{
if ($this->cache->has(md5($this->sourcePath))) {
$this->xmlParsedData = $this->cache->get(md5($this->sourcePath));
} else {
$this->xmlParsedData = $this->xmlParser->getParsedData($this->sourcePath);
$this->cache->set(md5($this->sourcePath), $this->xmlParsedData);
}
}
/**
* Validate that all required assertion steps of a badge were completed and remove the stored assertion steps for all tokens
*
* @param BadgeClass $badgeClass
* @param array $tokens
* @return boolean
*/
public function validateAndClearAssertionSteps(BadgeClass $badgeClass, array $tokens)
{
$completedAssertionSteps = array();
foreach ($tokens as $token) {
$assertionStep = $this->assertionStepStore->get($token);
if ($assertionStep instanceof AssertionStep && $assertionStep->getBadgeClass() === $badgeClass) {
$completedAssertionSteps[$assertionStep->getIdentifier()] = $assertionStep;
}
}
foreach ($badgeClass->getAssertionSteps() as $stepIdentifier) {
if (!isset($completedAssertionSteps[$stepIdentifier])) {
return FALSE;
}
}
foreach ($tokens as $token) {
$this->assertionStepStore->remove($token);
}
return TRUE;
}
/**
* When it's called, CLDR file is parsed or cache is loaded, if available.
*
* @return void
*/
public function initializeObject()
{
if ($this->cache->has($this->cacheKey)) {
$this->parsedData = $this->cache->get($this->cacheKey);
} else {
$this->parsedData = $this->parseFiles($this->sourcePaths);
$this->parsedData = $this->resolveAliases($this->parsedData, '');
$this->cache->set($this->cacheKey, $this->parsedData);
}
}
/**
* Loads reflection data from the cache or reflects the class if needed.
*
* If the class is completely unknown, this method won't try to load or reflect
* it. If it is known and reflection data has been loaded already, it won't be
* loaded again.
*
* In Production context, with frozen caches, this method will load reflection
* data for the specified class from the runtime cache.
*
* @param string $className Name of the class to load data for
* @return void
*/
protected function loadOrReflectClassIfNecessary($className)
{
if (!isset($this->classReflectionData[$className]) || is_array($this->classReflectionData[$className])) {
return;
}
if ($this->loadFromClassSchemaRuntimeCache === TRUE) {
$this->classReflectionData[$className] = $this->reflectionDataRuntimeCache->get(str_replace('\\', '_', $className));
} else {
$this->reflectClass($className);
}
}
/**
* Constructs the reader, loading parsed data from cache if available.
*
* @return void
*/
public function initializeObject()
{
if ($this->cache->has('rulesets') && $this->cache->has('rulesetsIndices')) {
$this->rulesets = $this->cache->get('rulesets');
$this->rulesetsIndices = $this->cache->get('rulesetsIndices');
} else {
$this->generateRulesets();
$this->cache->set('rulesets', $this->rulesets);
$this->cache->set('rulesetsIndices', $this->rulesetsIndices);
}
}
/**
* Loads reflection data from the cache or reflects the class if needed.
*
* If the class is completely unknown, this method won't try to load or reflect
* it. If it is known and reflection data has been loaded already, it won't be
* loaded again.
*
* In Production context, with frozen caches, this method will load reflection
* data for the specified class from the runtime cache.
*
* @param string $className Name of the class to load data for
* @return void
*/
protected function loadOrReflectClassIfNecessary($className)
{
if (!isset($this->classReflectionData[$className]) || is_array($this->classReflectionData[$className])) {
return;
}
if ($this->loadFromClassSchemaRuntimeCache === true) {
$this->classReflectionData[$className] = $this->reflectionDataRuntimeCache->get($this->produceCacheIdentifierFromClassName($className));
return;
}
$this->reflectClass($className);
}
/**
* Initializes this Policy Service
*
* @return void
*/
public function initializeObject()
{
$this->policy = $this->configurationManager->getConfiguration(\TYPO3\Flow\Configuration\ConfigurationManager::CONFIGURATION_TYPE_POLICY);
$this->setAclsForEverybodyRole();
if ($this->cache->has('acls')) {
$this->acls = $this->cache->get('acls');
} else {
$this->parseEntityAcls();
}
if ($this->cache->has('entityResourcesConstraints')) {
$this->entityResourcesConstraints = $this->cache->get('entityResourcesConstraints');
} else {
if (array_key_exists('resources', $this->policy) && array_key_exists('entities', $this->policy['resources'])) {
$this->entityResourcesConstraints = $this->policyExpressionParser->parseEntityResources($this->policy['resources']['entities']);
}
}
}
/**
* @param boolean
* @return array
*/
public function getDynamicTasks($dueOnly = FALSE)
{
$tasks = array();
$now = new Now();
foreach (self::getAllDynamicTaskImplementations($this->objectManager) as $dynamicTask) {
$task = new Task($dynamicTask['expression'], $dynamicTask['implementation']);
$cacheKey = md5($dynamicTask['implementation']);
$lastExecution = $this->dynamicTaskLastExecutionCache->get($cacheKey);
if ($dueOnly && ($lastExecution instanceof \DateTime && $now < $task->getNextExecution($lastExecution))) {
continue;
}
$task->enable();
$taskDecriptor = $this->getTaskDescriptor(TaskInterface::TYPE_DYNAMIC, $task);
$taskDecriptor['lastExecution'] = $lastExecution instanceof \DateTime ? $lastExecution->format(\DateTime::ISO8601) : '';
$taskDecriptor['identifier'] = '';
$tasks[] = $taskDecriptor;
}
return $tasks;
}
/**
* Get the size of a Flow Resource object that contains an image file.
*
* @param FlowResource $resource
* @return array width and height as keys
* @throws ImageFileException
*/
public function getImageSize(FlowResource $resource)
{
$cacheIdentifier = $resource->getCacheEntryIdentifier();
$imageSize = $this->imageSizeCache->get($cacheIdentifier);
if ($imageSize !== false) {
return $imageSize;
}
// TODO: Special handling for SVG should be refactored at a later point.
if ($resource->getMediaType() === 'image/svg+xml') {
$imageSize = ['width' => null, 'height' => null];
} else {
try {
$imagineImage = $this->imagineService->read($resource->getStream());
$sizeBox = $imagineImage->getSize();
$imageSize = array('width' => $sizeBox->getWidth(), 'height' => $sizeBox->getHeight());
} catch (\Exception $e) {
throw new ImageFileException(sprintf('The given resource was not an image file your choosen driver can open. The original error was: %s', $e->getMessage()), 1336662898);
}
}
$this->imageSizeCache->set($cacheIdentifier, $imageSize);
return $imageSize;
}
/**
* Shows the methods represented by the given security resource
*
* @param string $resourceName The name of the resource as stated in the policy
* @return void
*/
public function showMethodsForResourceCommand($resourceName)
{
if ($this->policyCache->has('acls')) {
$classes = array();
$acls = $this->policyCache->get('acls');
foreach ($acls as $classAndMethodName => $aclEntry) {
if (strpos($classAndMethodName, '->') === FALSE) {
continue;
}
list($className, $methodName) = explode('->', $classAndMethodName);
$className = $this->objectManager->getCaseSensitiveObjectName($className);
$reflectionClass = new \ReflectionClass($className);
foreach ($reflectionClass->getMethods() as $casSensitiveMethodName) {
if ($methodName === strtolower($casSensitiveMethodName->getName())) {
$methodName = $casSensitiveMethodName->getName();
break;
}
}
foreach ($aclEntry as $resources) {
if (array_key_exists($resourceName, $resources)) {
$classes[$className][$methodName] = $methodName;
break;
}
}
}
if (count($classes) === 0) {
$this->outputLine('The given Resource did not match any method or is unknown.');
$this->quit(1);
}
foreach ($classes as $className => $methods) {
$this->outputLine(PHP_EOL . $className);
foreach ($methods as $methodName) {
$this->outputLine(' ' . $methodName);
}
}
} else {
$this->outputLine('Could not find any policy entries, please warmup caches!');
}
}
/**
* @param string $importerClassName
* @param string $externalIdentifier
* @return ProcessedNodeDefinition
*/
public function get($importerClassName, $externalIdentifier)
{
$entryIdentifier = $this->getEntryIdentifier($importerClassName, $externalIdentifier);
return $this->cache->get($entryIdentifier);
}
/**
* Initialize the object and load caches
*/
public function initializeObject()
{
$this->postalCodeCoordinates = $this->cache->get('postalCodeCoordinates') ?: [];
$this->addressCoordinates = $this->cache->get('addressCoordinates') ?: [];
}
/**
* @return void
*/
public function initializeObject()
{
if ($this->methodPermissionCache->has('methodPermission')) {
$this->methodPermissions = $this->methodPermissionCache->get('methodPermission');
}
}
