Beispiel #1
0
 /**
  * @return string
  */
 public function JS()
 {
     $code = $this->getCode();
     if (is_string($code)) {
         $code = array($code);
         // blöde interfaces vom js helper
     } elseif ($code instanceof \Psc\JS\Expression) {
         $code = array($code->JS());
     }
     // load-wrappers (von innen nach außen)
     if ($this->onPscReady === 'main') {
         // non blocking mode (is save to use in html inline scripts directly)
         $this->unshiftRequirement('app/main');
         $this->unshiftRequirementAlias('main');
         $this->unshiftRequirement('jquery');
         $this->unshiftRequirementAlias('jQuery');
         $code = Helper::bootLoad($this->getRequirements(), $this->requirementsAliases, $code);
     } elseif ($this->onPscReady) {
         // is only save to use in ajax requests / inline scripts where window.requireLoad is already defined
         $this->unshiftRequirement('jquery');
         $this->unshiftRequirementAlias('jQuery');
         $code = Helper::requireLoad($this->getRequirements(), $this->requirementsAliases, $code);
     } elseif (count($req = $this->getRequirements()) > 0) {
         $code = Helper::requirejs($req, array(), $code);
     } else {
         $code = count($code) > 1 ? \Webforge\Common\ArrayUtil::join($code, "%s\n") : current($code);
     }
     return TPL::miniTemplate((string) $code, (array) $this->vars);
 }
Beispiel #2
0
 protected function hash($fqn, $uniqueData)
 {
     asort($uniqueData);
     return $fqn . '__' . A::implode($uniqueData, ',', function ($value, $field) {
         return $field . ':' . $value;
     });
 }
Beispiel #3
0
 protected function createRowFromArray(array $row)
 {
     foreach ($row as $column => $value) {
         if (!array_key_exists($column, $this->columns)) {
             throw new \Psc\Exception('Request eines unbekannten Spalten-Typs: "' . $column . '" ' . print_r(A::keys($row), true) . '. Wurde dieser mit addColumn() hinzugefügt?');
         }
         $cell = $this->sheet->setCellValue($this->columns[$column][0] . $this->row->getRowIndex(), $value, true);
     }
 }
Beispiel #4
0
 public function hydrate($entity, $data)
 {
     if (is_array($data) && !\Webforge\Common\ArrayUtil::isNumeric($data)) {
         // numeric bedeutet composite key (z.b. OID)
         return $this->getRepository($entity)->hydrateBy($data);
     } else {
         return $this->getRepository($entity)->hydrate($data);
     }
 }
Beispiel #5
0
 public function hasMethod($name, array $parameters = NULL)
 {
     $this->test->assertTrue($this->gClass->hasMethod($name), $this->msg("hasMethod '%s'. Methods avaible: [%s]", $name, implode(", ", A::pluck($this->gClass->getMethods(), 'name'))));
     $method = $this->gClass->getMethod($name);
     if (isset($parameters)) {
         $this->assertMethodParameters($method, $parameters);
     }
     $this->lastGet = $method;
     return $this;
 }
Beispiel #6
0
 public function walkArrayValue($phpValue, Type $type)
 {
     $isList = $type->isList() !== NULL ? $type->isList() : \Webforge\Common\ArrayUtil::isNumeric($phpValue);
     if ($isList) {
         return $this->walkListValue((array) $phpValue, $type);
     } else {
         return $this->walkHashMapValue((object) $phpValue, $type);
         // alternativ: doch lValue übergeben und lValue->castToHashMap() oder sowas haben
     }
 }
Beispiel #7
0
 public function insertRow(array $row, $index = self::END)
 {
     if (!is_integer($index) && $index !== self::END) {
         throw new \InvalidArgumentException('index muss ein integer sein. self::END f?r append');
     }
     if (!count($row) === count($this->columns)) {
         throw new \InvalidArgumentException("Zeile hat nicht %d Spalten sondern %d Spalten.", count($row), count($this->columns));
     }
     A::insert($this->rows, $row, $index);
     return $this;
 }
 /**
  * @return array
  */
 protected function parseParams($input)
 {
     $params = json_decode($json = $input->getArgument('parametersJSON'));
     if ($params === NULL) {
         throw new \InvalidArgumentException(sprintf("parametersJSON muss valides JSON sein: '%s' wurde übergeben", $json));
     }
     $params = (array) $params;
     if (\Webforge\Common\ArrayUtil::isNumeric($params)) {
         throw new \InvalidArgumentException(sprintf("parametesrJSON muss ein object sein, mit constructorParameterName => value oder propertyName => value"));
     }
     return $params;
 }
Beispiel #9
0
 protected function exportMixedValue($value)
 {
     if (is_array($value) && A::getType($value) === 'numeric') {
         return $this->getCodeWriter()->exportList($value);
     } elseif (is_array($value)) {
         return $this->getCodeWriter()->exportKeyList($value);
     } else {
         try {
             return $this->getCodeWriter()->exportBaseTypeValue($value);
         } catch (\Psc\Code\Generate\BadExportTypeException $e) {
             throw new \RuntimeException('In Argumenten oder Properties können nur Skalare DefaultValues stehen. Die value muss im Constructor stehen.', 0, $e);
         }
     }
 }
Beispiel #10
0
    public function run()
    {
        if (!isset($this->changes) || !is_array($this->changes)) {
            throw new \InvalidArgumentException('changes muss gesetzt sein');
        }
        if (!$this->changelog->exists()) {
            throw new \RuntimeException('changelogFile ' . $targetFile . ' muss existieren');
        }
        require $this->changelog;
        /* changeslist : 
           
           'bugfix: Im Sound Content stand nur "content" statt dem eigentlichen Soundtext',
           'geändert: Bei der Soundsuche wird bei sehr großen Results das Ergebnis auf 15 Einträge eingeschränkt'
           
           */
        /* version */
        //2.0.9-Beta
        $version = \Psc\Preg::qmatch($data[0]['version'], '/^([0-9]+)\\.([0-9]+)\\.([0-9]+)\\-(Alpha|Beta|Gamma)$/i', array(1, 2, 3, 4));
        if (!is_array($version)) {
            throw new \RuntimeException('Fehler beim Version Parsing. Alte Version ' . $oldVersion);
        }
        if ($this->versionIncrement === 'minor') {
            $version[2]++;
        } else {
            throw new \InvalidArgumentException('Kann nichts anderes als minor für versionIncrement');
        }
        $newVersion = vsprintf('%d.%d.%d-%s', $version);
        $php = <<<'PHP'
$data[] = array(
  'version'=>'%version%',
  'time'=>'%time%',
  'changelog'=>array(
    %changesList%
  )
);

PHP;
        $php = \Psc\TPL\TPL::miniTemplate($php, array('version' => $newVersion, 'time' => date('H:i d.m.Y'), 'changesList' => \Webforge\Common\ArrayUtil::implode($this->changes, ",\n    ", function ($change) {
            return var_export($change, true);
        })));
        $contents = $this->changelog->getContents();
        $pos = mb_strpos($contents, $needle = '$data = array();' . "\n");
        if ($pos === FALSE) {
            throw new \RuntimeException('Cannot Modify File: ' . \Webforge\Common\String::cutAt($contents, 300) . ' enhält nicht ' . $needle);
        }
        $pos += mb_strlen($needle);
        $contents = mb_substr($contents, 0, $pos) . $php . "\n" . mb_substr($contents, $pos);
        $this->changelog->writeContents($contents);
    }
Beispiel #11
0
 public function addRow($headline, $content, $index = self::END, $class = NULL)
 {
     if ($index === self::END) {
         $indexHeadline = $indexContent = self::END;
     } else {
         // wenn bei 0 eingefügt werden soll ist head = 0 und div = 1
         $indexHeadline = $index * 2;
         // wenn bei 2 eingefügt werden soll ist head = 4 (weil div+head 0 und div+head1 davor sind) und div = 5
         $indexContent = $indexHeadline + 1;
     }
     \Webforge\Common\ArrayUtil::insert($this->html->content, $head = new HTMLTag($this->getOption('headlineTag'), $headline, array('class' => $class)), $indexHeadline);
     \Webforge\Common\ArrayUtil::insert($this->html->content, $div = new HTMLTag($this->getOption('contentTag'), $content, array('class' => $class)), $indexContent);
     $head->addClass('ui-accordion-header');
     $div->setOption('br.openTag', TRUE)->setOption('tag.indent', $this->indent + 2);
 }
Beispiel #12
0
 /**
  * @param string $command nur der befehl oder mehrere (z. B. lb für list simple)
  * @param array $options alle optionen ohne - davor
  */
 protected function exec($command, array $options = array(), $append = NULL)
 {
     $cmd = sprintf('%s %s%s %s%s', SystemUtil::escapeShellArg($this->bin), $command, count($options) > 0 ? \Webforge\Common\ArrayUtil::join($options, ' -%s') : NULL, (string) escapeshellarg($this->rar), mb_strlen($append) > 0 ? ' ' . $append : NULL);
     $out = array();
     $ret = NULL;
     $out = System::execute($cmd, NULL, NULL, $stdout, $stderr, NULL, $ret);
     if ($ret !== 0) {
         throw new Exception(sprintf("Fehler '%s' beim Ausführen des Befehls '%s'. Rückgabe: %d", $out, $cmd, $ret));
     }
     /* sonderfall für listfiles denn das gibt immer $ret = 0 zurück, toll, was? */
     if (!empty($stderr)) {
         throw new Exception(sprintf("Fehler '%s' beim Ausführen des Befehls '%s'.", $stderr, $cmd));
     }
     return $out;
 }
Beispiel #13
0
 /**
  * @var mixed $print Closure|String wenn ein String wird dies als Attribute gesehen welches mit get$print() vom Objekt geladen werden kann
  */
 public static function listStrings($collection, $sep = ', ', $andsep = NULL, Closure $formatter = NULL)
 {
     $collection = Code::castArray($collection);
     $cnt = count($collection);
     if (isset($andsep) && $cnt >= 2) {
         $last = array_pop($collection);
     } else {
         $andsep = NULL;
     }
     $formatter = $formatter ?: function ($item) {
         return (string) $item;
     };
     $ret = A::implode($collection, $sep, $formatter);
     if (isset($andsep) && $last != NULL) {
         $ret .= $andsep . $formatter($last);
     }
     return $ret;
 }
Beispiel #14
0
    protected function compileClosure(GMethod $method, $closureName)
    {
        // wir erzeugen sowas hier (ohne semikolon am ende)
        /*
          parameter von $funcName sind $name und $type
         
          $funcName = function ($name, $type) use ($that) {
            return $that->funcName($name, $type);
          }
        */
        $code = <<<'PHP'
$%closureName% = function (%parameters%) use ($that) {
  return $that->%method%(%callParameters%);
}
PHP;
        $codeWithFuncArgs = <<<'PHP'
$%closureName% = function () use ($that) {
  return call_user_func_array(array($that, '%method%'), func_get_args());
}
PHP;
        // wenn die innere funktion func_get_args() benutzt, müssen wir call_user_func nehmen ($codeWithFuncArgs)
        if (mb_strpos($method->getBody(), 'func_get_args()')) {
            // das ist natürlich nicht so schön als entscheidung, aber false positive macht nichts (außer bissl performance)
            $code = $codeWithFuncArgs;
            $parameters = $callParameters = NULL;
        } else {
            // kopiert von GFunction
            $parameters = \Webforge\Common\ArrayUtil::implode($method->getParameters(), ', ', function ($parameter) {
                return $parameter->php($useFQNHints = TRUE);
            });
            $callParameters = \Webforge\Common\ArrayUtil::implode($method->getParameters(), ', ', function ($parameter) {
                // für die 2ten parameter entfernen wir alle hints, damit wir nur die parameter auflistungen haben
                $parameter = clone $parameter;
                $parameter->setHint(NULL);
                $parameter->setArray(FALSE);
                $parameter->setDefault(GParameter::UNDEFINED);
                return $parameter->php();
            });
        }
        $code = \Psc\TPL\TPL::miniTemplate($code, array('parameters' => $parameters, 'callParameters' => $callParameters, 'method' => $method->getName(), 'closureName' => $closureName));
        return $code;
    }
Beispiel #15
0
 public function testParameter()
 {
     $class = new ReflectionClass('Psc\\Code\\Generate\\ParameterTestClass');
     $method = $class->getMethod('comboBox');
     $params = $method->getParameters();
     $param = new GParameter();
     $param->elevate($params[4]);
     $this->assertEquals('commonItemData', $param->getName());
     $this->assertEquals(array(), $param->getDefault());
     $this->assertTrue($param->isOptional());
     $this->assertEquals('Array $commonItemData = array()', $param->php());
     $param = new GParameter();
     $param->elevate($params[3]);
     $this->assertEquals('$itemType = NULL', $param->php());
     $param = new GParameter();
     $param->elevate($params[0]);
     $this->assertEquals('$label', $param->php());
     $param = new GParameter();
     $param->elevate(A::index($class->getMethod('factory')->getParameters(), 0));
     $this->assertEquals('\\Psc\\Code\\Generate\\TestHint $dunno', $param->php($useFQN = TRUE));
 }
Beispiel #16
0
 protected function processErrors()
 {
     $errors = libxml_get_errors();
     if (count($errors) == 0) {
         $this->rollback();
         throw new LoadingException('Fehler beim Laden des XMLS, es konnten aber keine Fehlerinformationen ermittelt werden.');
     }
     $cnt = count($errors);
     if ($cnt == 1) {
         $msg = 'Beim Laden des XMLs ist ein Fehler aufgetreten: ';
     } else {
         $msg = sprintf('Beim Laden des XMLs sind %d Fehler aufgetreten: ', $cnt);
     }
     $that = $this;
     $e = new LoadingException($msg . "\n" . \Webforge\Common\ArrayUtil::joinc($errors, "\n   %s\n\n", function ($error) use($that) {
         return $that->errorToString($error);
     }));
     $e->libxmlErrors = $errors;
     libxml_clear_errors();
     $this->rollback();
     throw $e;
 }
Beispiel #17
0
 public function compile()
 {
     $gClass = new \Psc\Code\Generate\GClass(\Psc\Code\Code::getClass($this));
     $gClass->elevateClass();
     $this->log('compiling ProjectEntities:');
     foreach ($gClass->getMethods() as $method) {
         if (\Psc\Preg::match($method->getName(), '/^compile[a-z0-9A-Z_]+$/') && $method->isPublic()) {
             $this->modelCompiler = NULL;
             // neuen erzeugen damit flags resetted werden, etc
             $m = $method->getName();
             $this->log('  ' . $m . ':');
             try {
                 $out = $this->{$m}($this->getModelCompiler());
             } catch (\Doctrine\DBAL\DBALException $e) {
                 if (mb_strpos($e->getMessage(), 'Unknown column type') !== FALSE) {
                     $types = A::implode(\Doctrine\DBAL\Types\Type::getTypesMap(), "\n", function ($fqn, $type) {
                         return $type . "\t\t" . ': ' . $fqn;
                     });
                     throw new \Psc\Exception('Database Error: Unknown Column Type: types are: ' . "\n" . $types, $e->getCode(), $e);
                 }
                 throw $e;
             } catch (\Exception $e) {
                 $this->log('    Fehler beim Aufruf von ' . $m);
                 throw $e;
             }
             if ($out instanceof \Webforge\Common\System\File) {
                 $this->log('    ' . $out . ' geschrieben');
             } elseif (is_array($out)) {
                 foreach ($out as $file) {
                     $this->log('    ' . $file . ' geschrieben');
                 }
             } elseif ($out instanceof \Psc\Doctrine\EntityBuilder) {
                 $this->log('    ' . $out->getWrittenFile() . ' geschrieben');
             }
         }
     }
     $this->log('finished.');
     return $this;
 }
Beispiel #18
0
 protected static function buildRequirements(array $requirements)
 {
     return A::implode($requirements, ', ', function ($requirement) {
         return sprintf("'%s'", $requirement);
     });
 }
Beispiel #19
0
 public static function fromCode(array $codeLines)
 {
     return new static(\Webforge\Common\ArrayUtil::join($codeLines, "%s\n"));
 }
Beispiel #20
0
 protected function debugTokens(array $tokens)
 {
     return \Webforge\Common\ArrayUtil::joinc($tokens, ', ', function ($token) {
         return is_string($token) ? $token : j_token_name($token);
     });
 }
Beispiel #21
0
 /**
  * @param string|array $name ist dies ein array wird der Name in PHP-Post-Array Syntax zurückgegeben $name = "var[key1][key2]"
  */
 public static function getName($name)
 {
     if (is_array($name)) {
         $root = array_shift($name);
         $name = $root . A::join($name, '[%s]');
         return $name;
     }
     return $name;
 }
Beispiel #22
0
 /**
  * @param mixed[] $columns die Spalten in der richtigen Reihenfolge
  */
 public function addRow(array $row)
 {
     $this->init();
     $names = array_keys($this->columns);
     if (!A::isNumeric($row)) {
         throw new InvalidArgumentException('Bis jetzt nur numerische Arrays. Die Reihenfolge ist: ' . implode(', ', $names));
     }
     if (count($row) !== count($names)) {
         throw new InvalidArgumentException('Spalten für addRow haben nicht die richtige Anzahl. Die Reihenfolge ist: ' . implode(', ', $names));
     }
     $grid = $this->getGrid();
     $grid->tr();
     foreach ($row as $index => $value) {
         $column = $this->getColumn($names[$index]);
         // validate wäre schön nach type?
         $td = $grid->td()->setContent($value)->addClass($this->classify($column->getName()))->addClass($column->getClasses());
     }
     $grid->tr();
     return $this;
 }
Beispiel #23
0
 /**
  * Sucht den ersten der Services, der den Request bearbeiten will
  * 
  * @throws NoServiceFoundException
  */
 public function findService(ServiceRequest $serviceRequest)
 {
     $this->log('Find Services..');
     foreach ($this->services as $service) {
         $this->log('Service: ' . Code::getClass($service) . '::isResponsibleFor');
         if ($service->isResponsibleFor($serviceRequest)) {
             $this->log('ok: Service übernimmt den Request');
             return $service;
         }
     }
     throw NoServiceFoundException::build('Es konnte kein passender Service ermittelt werden. Es wurden %d Services (%s) befragt.', count($this->services), \Webforge\Common\ArrayUtil::implode($this->services, ', ', function ($svc) {
         return Code::getClass($svc);
     }))->set('serviceRequest', $serviceRequest)->end();
 }
Beispiel #24
0
 public function generatePHP(array $imports = array())
 {
     if (!isset($this->gClass)) {
         throw new ClassWritingException('Klasse nicht gesetzt. (zuerst setClass() dann write().');
     }
     $use = NULL;
     /* merge mit params */
     foreach ($imports as $iClass) {
         $alias = NULL;
         if (is_array($iClass)) {
             list($iClass, $alias) = $iClass;
         }
         if (!$iClass instanceof GClass) {
             throw new \Psc\Exception('Imports können nur vom typ GClass sein');
         }
         $this->addImport($iClass, $alias);
     }
     if (count($this->foundImports) > 0) {
         $useImports = array();
         foreach ($this->foundImports as $alias => $gClass) {
             // wir filten nach den imports, die im selben Namespace sind und keinen besonderen Alias haben
             if ($alias !== $gClass->getClassName() || $gClass->getNamespace() !== $this->gClass->getNamespace()) {
                 $useImports[$alias] = $gClass;
             }
         }
         /* Render PHP */
         $classAlias = function ($gClass, $alias) {
             if ($alias === $gClass->getClassName()) {
                 return $gClass->getFQN();
             } else {
                 return $gClass->getFQN() . ' AS ' . $alias;
             }
         };
         if (count($useImports) > 0) {
             $use .= "\n";
             // abstand zu namespace (neue Zeile)
             if ($this->useStyle === self::USE_STYLE_LINES) {
                 $use .= A::joinc($useImports, "use %s;\n", $classAlias);
             } else {
                 $use .= 'use ' . A::implode($useImports, ",\n    ", $classAlias);
                 $use .= ';';
                 $use .= "\n";
                 // abstand zu class (neue Zeile)
             }
         }
     }
     $php = TPL::miniTemplate($this->template, array('class' => $this->gClass->php(), 'use' => $use, 'namespace' => $this->gClass->getNamespace() != NULL ? 'namespace ' . ltrim($this->gClass->getNamespace(), '\\') . ';' : NULL));
     return $php;
 }
Beispiel #25
0
 public function debug()
 {
     print \Webforge\Common\ArrayUtil::join($this->log, "    [phar] %s\n");
 }
Beispiel #26
0
 /**
  * Gibt das HTML zum Laden von allen CSS Dateien aus
  */
 public function load($glue = "%s \n")
 {
     print A::join($this->getHTML(), "%s \n");
 }
Beispiel #27
0
 /**
  * @param array ein identifier array mit columnname => value der id-werte
  * @return string|id gibt den Identifier als Scalar Value zurück
  */
 public static function _getIdentifierHash(array $identifiers)
 {
     if (count($identifiers) == 1) {
         return A::peek($identifiers);
     } elseif (count($identifiers) > 0) {
         ksort($identifiers);
         return implode('.', $identifiers);
     } else {
         throw new Exception('Kein Hash für leere identifiers möglich');
     }
 }
Beispiel #28
0
 public function generateDataRandomType(array $types)
 {
     return $this->generateData(A::randomValue($types));
 }
Beispiel #29
0
 public function insertBody(array $codeLines, $index)
 {
     $this->getBodyCode();
     \Webforge\Common\ArrayUtil::insertArray($this->bodyCode, $codeLines, $index);
     return $this;
 }
Beispiel #30
0
 /**
  * Findet den Controller anhand des Requests
  * 
  * GET [/$prefix]/person/1
  *  =>
  * \Project::getNamespace()\Controllers\PersonController::getEntity(1)
  * =>
  * \CoC\Controllers\PersonController::getEntity(1)
  *
  * GET [/$prefix]/person/1/form
  * =>
  * \Project::getNamespace()\Controllers\PersonController::getEntity(1,'form')
  *
  * GET [/$prefix]/persons/grid?filter1=value1&filter2=value2
  * =>
  * \Project::getNamespace()\Controllers\PersonController::getEntities(array('filter1'=>'value1', 'filter2'=>'value2'),'grid')
  */
 public function routeController(ServiceRequest $request)
 {
     $r = $this->initRequestMatcher($request);
     $entityPart = $r->qmatchRx('/^[a-z-0-9]+$/i', 0);
     if (mb_strpos($entityPart, '-') !== FALSE) {
         $entityPart = Code::dashToCamelCase($entityPart);
     }
     // alle weiteren Parameter an den Controller weitergeben
     $params = $r->getLeftParts();
     if ($request->getType() === self::GET) {
         $this->log('EntityPart: ' . $entityPart . ' ' . ($this->isPlural($entityPart) ? 'ist plural' : 'ist singular'), 2);
         if ($this->isPlural($entityPart)) {
             if ($r->part() === 'form') {
                 $method = 'getNewEntityFormular';
             } else {
                 $method = 'getEntities';
                 A::insert($params, $request->getQuery(), 0);
                 // query als 1. parameter
             }
             $entityPart = Inflector::singular($entityPart);
         } else {
             $method = 'getEntity';
             $params = array();
             $params[] = $r->shift();
             // id
             $params[] = count($r->getLeftParts()) > 1 ? $r->getLeftParts() : $r->shift();
             // subresource
             $params[] = $request->getQuery();
         }
     } elseif ($request->getType() === self::PUT) {
         if ($r->part() === 'grid') {
             $entityPart = Inflector::singular($entityPart);
             $controller = $this->getEntityController($entityPart);
             $method = 'saveSort';
             $params = array($r->bvar($controller->getSortField(), array()));
         } elseif ($request->hasMeta('revision') && $request->getMeta('revision') !== 'default') {
             $method = 'saveEntityAsRevision';
             A::insert($params, $request->getMeta('revision'), 1);
             A::insert($params, (object) $request->getBody(), 2);
         } else {
             $method = 'saveEntity';
             A::insert($params, (object) $request->getBody(), 1);
             // $formData als parameter 2
         }
     } elseif ($request->getType() === self::PATCH) {
         $method = 'patchEntity';
         A::insert($params, (object) $request->getBody(), 1);
         // $formData als parameter 2
     } elseif ($request->getType() === self::DELETE) {
         $method = 'deleteEntity';
         // das gibt einen "missing argument 1" fehler, wenn id fehlt, aber ka welche httpException ich hier nehmensoll, deshalb bleibt das erstmal so
     } elseif ($request->getType() === self::POST) {
         $entityPart = Inflector::singular($entityPart);
         // singular und plural okay
         A::insert($params, $request->getBody(), 0);
         // $formData als parameter 1
         if ($request->hasMeta('revision')) {
             $method = 'insertEntityRevision';
             A::insert($params, $request->getMeta('revision'), 0);
         } else {
             $method = 'insertEntity';
         }
     } else {
         // das kann glaub ich nicht mehr passieren, weil wir jetzt alle haben: put/pust/delete/get gibts nicht noch head?
         throw HTTPException::MethodNotAllowed('Die Methode: ' . $request->getType() . ' ist für diesen Request nicht erlaubt');
     }
     if (!isset($controller)) {
         $controller = $this->getEntityController($entityPart);
     }
     return array($controller, $method, $params);
 }