/**
  * Generate a controller for a package. The package key can contain
  * a subpackage with a slash after the package key (e.g. "MyPackage/Admin").
  *
  * @param string $packageKey The package key of the package for the new controller with an optional subpackage
  * @param string $controllerName The name for the new controller. This may also be a comma separated list of controller names.
  * @return void
  * @author Christopher Hlubek <*****@*****.**>
  */
 public function generateControllerAction($packageKey, $controllerName = 'Standard')
 {
     $subpackageName = '';
     if (strpos('/', $packageKey) !== FALSE) {
         list($packageKey, $subpackageName) = explode('/', $packageKey, 2);
     }
     if (!$this->packageManager->isPackageKeyValid($packageKey)) {
         return 'Package key "' . $packageKey . '" is not valid. Only UpperCamelCase with alphanumeric characters and underscore, please!' . PHP_EOL;
     }
     if (!$this->packageManager->isPackageAvailable($packageKey)) {
         return 'Package "' . $packageKey . '" is not available.' . PHP_EOL;
     }
     $generatedFiles = array();
     $controllerNames = \F3\FLOW3\Utility\Arrays::trimExplode(',', $controllerName);
     foreach ($controllerNames as $currentControllerName) {
         $generatedFiles += $this->generatorService->generateController($packageKey, $subpackageName, $currentControllerName);
     }
     return implode(PHP_EOL, $generatedFiles) . PHP_EOL;
 }
 /**
  * Merges all routes in $routesConfiguration with the sub routes in $subRoutesConfiguration
  *
  * @param array $routesConfiguration
  * @param array $subRoutesConfiguration
  * @param string $subRouteKey the key of the sub route: <subRouteKey>
  * @return array the merged route configuration
  * @author Bastian Waidelich <*****@*****.**>
  */
 protected function buildSubrouteConfigurations(array $routesConfiguration, array $subRoutesConfiguration, $subRouteKey)
 {
     $mergedSubRoutesConfiguration = array();
     foreach ($subRoutesConfiguration as $subRouteConfiguration) {
         foreach ($routesConfiguration as $routeConfiguration) {
             $name = isset($routeConfiguration['name']) ? $routeConfiguration['name'] : $routeConfiguration;
             $name .= ' :: ';
             $name .= isset($subRouteConfiguration['name']) ? $subRouteConfiguration['name'] : 'Subroute';
             $uriPattern = str_replace('<' . $subRouteKey . '>', $subRouteConfiguration['uriPattern'], $routeConfiguration['uriPattern']);
             $defaults = isset($routeConfiguration['defaults']) ? $routeConfiguration['defaults'] : array();
             if (isset($subRouteConfiguration['defaults'])) {
                 $defaults = \F3\FLOW3\Utility\Arrays::arrayMergeRecursiveOverrule($defaults, $subRouteConfiguration['defaults']);
             }
             $routeParts = isset($routeConfiguration['routeParts']) ? $routeConfiguration['routeParts'] : array();
             if (isset($subRouteConfiguration['routeParts'])) {
                 $routeParts = \F3\FLOW3\Utility\Arrays::arrayMergeRecursiveOverrule($routeParts, $subRouteConfiguration['routeParts']);
             }
             $mergedSubRoutesConfiguration[] = array('name' => $name, 'uriPattern' => $uriPattern, 'defaults' => $defaults, 'routeParts' => $routeParts);
         }
     }
     return $mergedSubRoutesConfiguration;
 }
 /**
  * Around advice
  *
  * @around method(F3\FLOW3\MVC\Web\Routing\Router->resolve())
  * @param F3\FLOW3\AOP\JoinPointInterface $joinPoint The current join point
  * @return string Result of the target method
  * @author Bastian Waidelich <*****@*****.**>
  * @author Karsten Dambekalns <*****@*****.**>
  */
 public function cacheResolveCall(\F3\FLOW3\AOP\JoinPointInterface $joinPoint)
 {
     $routeValues = $joinPoint->getMethodArgument('routeValues');
     $routeValues = $this->convertObjectsToHashes($routeValues);
     \F3\FLOW3\Utility\Arrays::sortKeysRecursively($routeValues);
     $cacheIdentifier = md5(http_build_query($routeValues));
     if ($this->resolveCache->has($cacheIdentifier)) {
         return $this->resolveCache->get($cacheIdentifier);
     }
     $matchingUri = $joinPoint->getAdviceChain()->proceed($joinPoint);
     if ($matchingUri !== '') {
         $this->resolveCache->set($cacheIdentifier, $matchingUri);
     }
     return $matchingUri;
 }
예제 #4
0
 /**
  * Checks whether $requestPath corresponds to this Route.
  * If all Route Parts match successfully TRUE is returned and
  * $this->matchResults contains an array combining Route default values and
  * calculated matchResults from the individual Route Parts.
  *
  * @param string $requestPath the request path without protocol, host and query string
  * @return boolean TRUE if this Route corresponds to the given $requestPath, otherwise FALSE
  * @author Bastian Waidelich <*****@*****.**>
  * @see getMatchResults()
  */
 public function matches($requestPath)
 {
     $this->matchResults = NULL;
     if ($requestPath === NULL) {
         return FALSE;
     }
     if ($this->uriPattern === NULL) {
         return FALSE;
     }
     if (!$this->isParsed) {
         $this->parse();
     }
     $matchResults = array();
     $requestPath = trim($requestPath, '/');
     $skipOptionalParts = FALSE;
     $optionalPartCount = 0;
     foreach ($this->routeParts as $routePart) {
         if ($routePart->isOptional()) {
             $optionalPartCount++;
             if ($skipOptionalParts) {
                 if ($routePart->getDefaultValue() === NULL) {
                     return FALSE;
                 }
                 continue;
             }
         } else {
             $optionalPartCount = 0;
             $skipOptionalParts = FALSE;
         }
         if (!$routePart->match($requestPath)) {
             if ($routePart->isOptional() && $optionalPartCount === 1) {
                 if ($routePart->getDefaultValue() === NULL) {
                     return FALSE;
                 }
                 $skipOptionalParts = TRUE;
             } else {
                 return FALSE;
             }
         }
         if ($routePart->getValue() !== NULL) {
             $matchResults[$routePart->getName()] = $routePart->getValue();
         }
     }
     if (strlen($requestPath) > 0) {
         return FALSE;
     }
     $this->matchResults = \F3\FLOW3\Utility\Arrays::arrayMergeRecursiveOverrule($this->defaults, $matchResults);
     return TRUE;
 }
예제 #5
0
 /**
  * Transforms the convoluted _FILES superglobal into a manageable form.
  *
  * @param array $convolutedFiles The _FILES superglobal
  * @return array Untangled files
  */
 protected function untangleFilesArray(array $convolutedFiles)
 {
     $untangledFiles = array();
     $fieldPaths = array();
     foreach ($convolutedFiles as $firstLevelFieldName => $fieldInformation) {
         if (!is_array($fieldInformation['error'])) {
             $fieldPaths[] = array($firstLevelFieldName);
         } else {
             $newFieldPaths = $this->calculateFieldPaths($fieldInformation['error'], $firstLevelFieldName);
             array_walk($newFieldPaths, function (&$value, $key) {
                 $value = explode('/', $value);
             });
             $fieldPaths = array_merge($fieldPaths, $newFieldPaths);
         }
     }
     foreach ($fieldPaths as $fieldPath) {
         if (count($fieldPath) === 1) {
             $fileInformation = $convolutedFiles[$fieldPath[0]];
         } else {
             $fileInformation = array();
             foreach ($convolutedFiles[$fieldPath[0]] as $key => $subStructure) {
                 $fileInformation[$key] = \F3\FLOW3\Utility\Arrays::getValueByPath($subStructure, array_slice($fieldPath, 1));
             }
         }
         $untangledFiles = \F3\FLOW3\Utility\Arrays::setValueByPath($untangledFiles, $fieldPath, $fileInformation);
     }
     return $untangledFiles;
 }
예제 #6
0
 /**
  * Builds the URI
  *
  * @return string The URI
  * @api
  * @author Bastian Waidelich <*****@*****.**>
  */
 public function build()
 {
     $arguments = array();
     if ($this->addQueryString === TRUE) {
         $arguments = $this->request->getArguments();
         foreach ($this->argumentsToBeExcludedFromQueryString as $argumentToBeExcluded) {
             unset($arguments[$argumentToBeExcluded]);
         }
     }
     $arguments = \F3\FLOW3\Utility\Arrays::arrayMergeRecursiveOverrule($arguments, $this->arguments);
     $uri = $this->router->resolve($arguments);
     $this->lastArguments = $arguments;
     if ($this->section !== '') {
         $uri .= '#' . $this->section;
     }
     if (!$this->environment->isRewriteEnabled()) {
         $uri = 'index.php/' . $uri;
     }
     if ($this->createAbsoluteUri === TRUE) {
         $uri = $this->request->getBaseUri() . $uri;
     }
     return $uri;
 }
 /**
  * Checks, resolves and injects dependencies as properties through calling the setter methods or setting
  * properties directly through reflection.
  *
  * @param array $properties Array of \F3\FLOW3\Object\Configuration\ConfigurationProperty for the current object
  * @param object $object The recently created instance of the current object. Dependencies will be injected to it.
  * @return void
  * @author Robert Lemke <*****@*****.**>
  */
 protected function injectProperties($properties, $object)
 {
     foreach ($properties as $propertyName => $property) {
         $propertyValue = $property->getValue();
         switch ($property->getType()) {
             case \F3\FLOW3\Object\Configuration\ConfigurationProperty::PROPERTY_TYPES_OBJECT:
                 if ($propertyValue instanceof \F3\FLOW3\Object\Configuration\Configuration) {
                     $preparedValue = $this->createObject($propertyValue->getObjectName(), $propertyValue);
                 } else {
                     if (strpos($propertyValue, '.') !== FALSE) {
                         $settingPath = explode('.', $propertyValue);
                         $settings = $this->configurationManager->getConfiguration(\F3\FLOW3\Configuration\ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, array_shift($settingPath));
                         $propertyValue = \F3\FLOW3\Utility\Arrays::getValueByPath($settings, $settingPath);
                     }
                     $preparedValue = $this->objectManager->getObject($propertyValue);
                 }
                 break;
             case \F3\FLOW3\Object\Configuration\ConfigurationProperty::PROPERTY_TYPES_STRAIGHTVALUE:
                 $preparedValue = $propertyValue;
                 break;
             case \F3\FLOW3\Object\Configuration\ConfigurationProperty::PROPERTY_TYPES_SETTING:
                 if (strpos($propertyValue, '.') !== FALSE) {
                     $settingPath = explode('.', $propertyValue);
                     $settings = $this->configurationManager->getConfiguration(\F3\FLOW3\Configuration\ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, array_shift($settingPath));
                     $preparedValue = \F3\FLOW3\Utility\Arrays::getValueByPath($settings, $settingPath);
                 } else {
                     $preparedValue = $this->configurationManager->getConfiguration(\F3\FLOW3\Configuration\ConfigurationManager::CONFIGURATION_TYPE_SETTINGS, $propertyValue);
                 }
                 break;
         }
         $setterMethodName = 'inject' . ucfirst($propertyName);
         if (method_exists($object, $setterMethodName)) {
             $object->{$setterMethodName}($preparedValue);
             continue;
         }
         $setterMethodName = 'set' . ucfirst($propertyName);
         if (method_exists($object, $setterMethodName)) {
             $object->{$setterMethodName}($preparedValue);
             continue;
         }
         if (property_exists($object, $propertyName)) {
             $propertyReflection = new \ReflectionProperty($object, $propertyName);
             $propertyReflection->setAccessible(TRUE);
             $propertyReflection->setValue($object, $preparedValue);
         }
     }
 }
예제 #8
0
 /**
  * @test
  * @author Robert Lemke <*****@*****.**>
  */
 public function getValueByPathReturnsNullIfThePathHasMoreSegmentsThanTheGivenArray()
 {
     $array = array('Foo' => array('Bar' => array('Baz' => 'the value')));
     $this->assertNULL(\F3\FLOW3\Utility\Arrays::getValueByPath($array, array('Foo', 'Bar', 'Baz', 'Bux')));
 }
 /**
  * Takes the raw request data and - depending on the request method
  * maps them into the request object. Afterwards all mapped arguments
  * can be retrieved by the getArgument(s) method, no matter if they
  * have been GET, POST or PUT arguments before.
  *
  * @param \F3\FLOW3\MVC\Web\Request $request The web request which will contain the arguments
  * @return void
  * @author Robert Lemke <*****@*****.**>
  */
 protected function setArgumentsFromRawRequestData(\F3\FLOW3\MVC\Web\Request $request)
 {
     foreach ($request->getRequestUri()->getArguments() as $argumentName => $argumentValue) {
         $request->setArgument($argumentName, $argumentValue);
     }
     switch ($request->getMethod()) {
         case 'POST':
             foreach ($this->environment->getRawPostArguments() as $argumentName => $argumentValue) {
                 $request->setArgument($argumentName, $argumentValue);
             }
             foreach ($this->environment->getUploadedFiles() as $argumentName => $argumentValue) {
                 if ($request->hasArgument($argumentName)) {
                     $existingArgumentValue = $request->getArgument($argumentName);
                     if (is_array($existingArgumentValue)) {
                         $request->setArgument($argumentName, \F3\FLOW3\Utility\Arrays::arrayMergeRecursiveOverrule($existingArgumentValue, $argumentValue));
                     }
                 } else {
                     $request->setArgument($argumentName, $argumentValue);
                 }
             }
             break;
             #			case 'PUT' :
             #				$putArguments = array();
             #				parse_str(file_get_contents("php://input"), $putArguments);
             #				foreach ($putArguments as $argumentName => $argumentValue) {
             #					$request->setArgument($argumentName, $argumentValue);
             #				}
             #			break;
     }
 }