RouteOne
1.33
Es liest die URL-Route und analysiert die Pfadwerte, sodass sie auf schnellstmögliche Weise manuell oder automatisch interpretiert werden können (z. B. zur Implementierung eines MVC-Systems).
Im Gegensatz zu anderen Bibliotheken weist diese Bibliothek keine Abhängigkeiten auf und ist in einer einzigen Klasse enthalten, sodass sie mit jedem PHP-Projekt kompatibel ist, zum Beispiel WordPress, Laravel, Drupal, einem benutzerdefinierten PHP-Projekt usw.
Diese Bibliothek basiert auf CoC Convention over Configuration . Es reduziert den Standardaufwand, verfügt aber über feste Funktionalitäten. Diese Bibliothek ermöglicht die Verwendung benutzerdefinierter „Routen“ nicht, deckt jedoch praktisch alle Fälle ab, erhöht also die Leistung und Benutzerfreundlichkeit, geht aber auf Kosten der Flexibilität.
Nehmen wir an, wir haben die nächste URL http://somedomain.dom/Customer/Update/2. Diese Bibliothek konvertiert diese URL in Variablen, die verarbeitet oder direkt eine Methode aufgerufen werden können.
route.php
$ route = new RouteOne ( ' http://www.somedomain.dom ' );
$ route -> addPath ( ' api/{controller}/{action}/{id} ' );
$ route -> addPath ( ' {controller}/{action}/{id}/{idparent} ' );
$ route -> fetchPath ();
$ this -> callObjectEx ( ' cocacolacontroller{controller}Controller ' );ControllerCustomerController.php-Klasse
namespace cocacola controller ;
class CustomerController {
public function updateAction ( $ id = null , $ idparent = null , $ event = null ) {
echo " We want to update the customer $ id " ;
}
}
Nehmen wir an, wir führen die nächste Operation durch:
Ein Benutzer ruft die nächste Website http://somedomain.com/Customer/Insert auf, er möchte ein Formular zum Einfügen eines Kunden anzeigen
use eftec RouteOne RouteOne ;
$ route = new RouteOne ( ' . ' , null , null ); // Create the RouteOne Class
$ route -> fetch (); // fetch all the input values (from the route, get, post and such).
$ route -> callObject ( ' somenamespace \ controller \ %sController ' ); // where it will call the class CustomerController* oder
use eftec RouteOne RouteOne ;
$ route = new RouteOne ( ' . ' , null , null ); // Create the RouteOne Class
$ route -> fetch (); // fetch all the input values (from the route, get, post and such).
$ route -> callObjectEx ( ' somenamespace \ controller \ {controller}Controller ' ); // where it will call the class CustomerController* Dieser Code ruft die Methode InsertActionGet (GET), InsertActionPost (POST) oder InsertAction (GET/POST) innerhalb der Klasse Customer auf
Die aufgerufene Methode wird wie folgt geschrieben:
class Customer {
public function insertAction ( $ id = "" , $ idparent = "" , $ event = "" ) {
// here we do our operation.
}
}Nehmen wir an, wir möchten eine Kundennummer 20 aktualisieren , dann könnten wir die nächste Seite aufrufen
http://somedomain.com/Customer/Update/20
wobei 20 die „$id“ des zu bearbeitenden Kunden ist (es könnte eine Zahl oder eine Zeichenfolge sein)
Und was ist, wenn wir einen Kunden Nummer 20 des Unternehmens APPL aktualisieren möchten?
http://somedomain.com/Customer/Update/20/APPL
Dabei ist APPL der idparent
Nehmen wir an, wir klicken auf eine Schaltfläche oder führen eine Aktion aus. Es könnte vom Feld _event erfasst werden und wird vom Argument $event gelesen. Diese Variable kann per GET oder POST gesendet werden.
http://somedomain.com/Customer/Update/20/APPL?_event=click
Hinweis: Module werden automatisch abgerufen, wenn Sie addPath() und fetchPath() verwenden, Sie müssen es also nicht angeben. Nehmen wir an, unser System ist modular und wir haben mehrere Kunden (interne Kunden, externe usw.).
$ route = new RouteOne ( ' . ' , null , true ); // true indicates it is modular.oder
$ route = new RouteOne ( ' . ' , null ,[ ' Internal ' ]); // or we determine the module automatically. In this case, every url that starts with InternalDann
$ route -> fetch ();
$ route -> callObject ( ' somenamespace \ %2s% \ controller \ %1sController ' );http://somedomain.com/Internal/Customer/Update/20/APPL?_event=click
Dann ist die erste Verzweigung der Name des Moduls ( Internal ) und es ruft die Klasse somenamespaceInternalcontrollerCustomerController auf
Composer benötigen eftec/ RouteOne
Linux:
vendor/bin/ RouteOne cli -init (if the binary does not work, then chage the permission to execution)Windows:
. v endor b in r outeonecli.bat -initEs wird die Datei .htaccess erstellt und die Datei route.php und route.php haben eine Standardkonfiguration.
const BASEURL = " http://localhost " ; // Base url edit this value.
const BASEWEBNS = " eftec \ controller " ; // Base namespace (web) edit this value
const BASEAPINS = " eftec \ api " ; // Base namespace (api) edit this valueSpäter können Sie den Code in dieser Datei hinzufügen oder bearbeiten.
<IfModule mod_rewrite.c>
<IfModule mod_negotiation.c>
Options -MultiViews -Indexes
</IfModule>
RewriteEngine On
DirectoryIndex route.php
# Handle Authorization Header
RewriteCond %{HTTP:Authorization} .
RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
# Redirect Trailing Slashes If Not A Folder...
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_URI} (.+)/$
RewriteRule ^ %1 [L,R=301]
# Send Requests To Front Controller...
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME} !-f
RewriteRule ^ route.php?req=$1 [L,QSA]
</IfModule>
Wenn Ihr Webhost die Option FollowSymlinks nicht zulässt, versuchen Sie, sie durch Options +SymLinksIfOwnerMatch zu ersetzen.
Die wichtige Zeile lautet:
RewriteRule ^(.*)$ route.php?req=$1 [L,QSA] # Der anzurufende Router.
server {
listen 80;
server_name localhost;
root /example.com/public;
add_header X-Frame-Options "SAMEORIGIN";
add_header X-XSS-Protection "1; mode=block";
add_header X-Content-Type-Options "nosniff";
index index.html index.htm index.php;
charset utf-8;
location / {
try_files $uri $uri/ /router.php?req=$document_uri&$query_string;
}
location = /favicon.ico { access_log off; log_not_found off; }
location = /robots.txt { access_log off; log_not_found off; }
error_page 404 /index.php;
location ~ .php$ {
fastcgi_pass unix:/var/run/php/php7.2-fpm.sock;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
include fastcgi_params;
}
location ~ /.(?!well-known).* {
deny all;
}
}
Die wichtige Zeile lautet:
try_files $uri $uri/ /router.php?req=$document_uri&$query_string;
server {
listen 80;
server_name localhost;
root c:/www;
add_header X-Frame-Options "SAMEORIGIN";
add_header X-XSS-Protection "1; mode=block";
add_header X-Content-Type-Options "nosniff";
index index.html index.htm index.php;
charset utf-8;
location / {
try_files $uri $uri/ /router.php?req=$document_uri&$query_string;
}
location = /favicon.ico { access_log off; log_not_found off; }
location = /robots.txt { access_log off; log_not_found off; }
error_page 404 /index.php;
location ~ .php$ {
fastcgi_pass 127.0.0.1:9000;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
include fastcgi_params;
}
location ~ /.(?!well-known).* {
deny all;
}
}
Die wichtige Zeile lautet:
try_files $uri $uri/ /router.php?req=$document_uri&$query_string;
Dabei ist router.php die Datei, die als Router fungiert. ?req=$1 ist wichtig, da das System die Route von „req“ liest.
// router.php
$ route = new RouteOne (); // Create the RouteOne Class
$ route -> fetch (); // fetch all the input values (from the route, get, post and such).
$ route -> callObject ( ' somenamespace \ controller \ %sController ' ); // where it will call the class somenamespacecontrollerCustomerController Notiz:
Wenn Sie ein anderes Argument als „req“ verwenden möchten, können Sie es mit dem nächsten Code ändern:
$route->argumentName='newargument';
Seit 1.21 ist es möglich, einen benutzerdefinierten Pfad anstelle eines vordefinierten Pfads zu verwenden. Dies ist die empfohlene Methode. Die andere Methode ist noch vorhanden.
Syntax:
clearPath()
Es löscht alle definierten Pfade
Syntax:
addPath($path, $name = null,callable $middleWare=null)
Es fügt Pfade hinzu, die mit fetchPath() ausgewertet werden könnten
Beispiel:
$ this -> addPath ( ' api/{controller}/{action}/{id:0} ' , ' apipath ' );
$ this -> addPath ( ' /api/{controller}/{action}/{id:0}/ ' , ' apipath ' ); // "/" at the beginner and end are trimmed.
$ this -> addPath ( ' {controller}/{action}/{id:0} ' , ' webpath ' );
$ this -> addPath ( ' {controller:root}/{action}/{id:0} ' , ' webpath ' ); // root path using default
$ this -> addPath ( ' somepath ' , ' namepath ' ,
function ( callable $ next , $ id = null , $ idparent = null , $ event = null ) {
echo " middleware n" ;
$ result = $ next ( $ id , $ idparent , $ event ); // calling the controller
echo " endmiddleware n" ;
return $ result ;
}); Notiz:
Der erste Teil des Pfads vor dem „{“ wird verwendet, um zu bestimmen, welcher Pfad verwendet wird.
Beispiel „path/{controller}“ und „path/{controller}/{id}“, das System geht davon aus, dass es sich um denselben Pfad handelt
Parameterzeichenfolge $path Der Pfad, Beispiel „aaa/{controller}/{action:default}/{id}“
Dabei ist Standard der optionale Standardwert.
Parameter string|null $name (optional), der Name des Pfades
Parameter callable|null $middleWare Eine aufrufbare Funktion, die für Middleware verwendet wird.
Das erste Argument der Funktion muss eine aufrufbare Methode sein
Die nächsten Argumente müssen die durch callObjectEx definierten Argumente sein
(id,idparent,event)
Der Pfad könnte mit einem statischen Ort beginnen, der Rest des Pfades muss jedoch durch Variablen definiert (umschlossen von {}) und durch „/“ getrennt werden.
Sie können auch einen Standardwert für einen Pfad festlegen, indem Sie „:“ nach dem Namen der Variablen schreiben: {name:defaultvalue}
Der Name könnte mit $this->currentPath ermittelt werden. Wenn Sie einen Namen mit demselben Namen hinzufügen, wird dieser ersetzt.
Wenn Sie keinen Namen festlegen, wird ein autonumerischer Wert verwendet.
Der Name wird auch zurückgegeben, wenn Sie $this->fetchPath() aufrufen.
Beispiel:
$ this -> addPath ( ' {controller}/{id}/{idparent} ' );
$ this -> addPath ( ' myapi/otherfolder/{controller}/{id}/{idparent} ' );
$ this -> addPath ( ' {controller:defcontroller}/{action:defaction}/{id:1}/{idparent:2} ' );
// url: /dummy/10/20 =>(controller: dummy, id=10, idparent=20)
// url: /myapi/otherfolder/dummy/10/20 =>(controller: dummy, id=10, idparent=20)Sie können verschiedene Pfade definieren, es wird jedoch nur der erste Teil des Pfads verwendet, der mit einer URL übereinstimmt. „path/somepath/{id}“ funktioniert. „path/{id}/other“ funktioniert nicht
Syntax:
fetchPath()
Es ruft den zuvor durch addPath definierten Pfad ab und gibt den Namen (oder die Nummer) des Pfads zurück. Wenn es nicht gefunden wird, wird „false“ zurückgegeben
Beispiel:
$ route = new RouteOne ( ' http://www.example.dom ' );
$ route -> addPath ( ' {controller}/{id}/{idparent} ' , ' optionalname ' );
// if the url is : http://www.example.dom/customer/1/200 then it will return
echo $ route -> fetchPath (); // optionalname
echo $ route -> controller ; // customer
echo $ route -> id ; // 1
echo $ route -> idparent ; // 200 Es erhält einen Abfragewert (URL).
Hinweis: Diese Abfrage enthält nicht die Werte „req“, „_event“ und „_extra“.
Beispiel:
// http://localhost/..../?id=hi
$ id = $ router -> getQuery ( " id " ); // hi
$ nf = $ router -> getQuery ( " something " , " not found " ); // not foundEs legt einen Abfragewert fest
Beispiel:
$ route -> setQuery ( " id " , " hi " );
$ id = $ router -> getQuery ( " id " ); // hiSintax:
fetchPath()
Rufen Sie die Werte von der Route ab und die Werte werden verarbeitet.
Sintax
callObjectEx($classStructure, $throwOnError, $method, $methodGet, $methodPost,$arguments,$injectArguments)
Es erstellt eine neue Instanz eines Objekts (z. B. ein Controller-Objekt) und ruft die Methode auf.
Hinweis: Es handelt sich um eine erweiterte Version von this::callObject()
Diese Methode verwendet {}, um Werte basierend auf den nächsten Variablen zu ersetzen:
| Etikett | Beschreibung |
|---|---|
| {Regler} | Der Name des Controllers |
| {Aktion} | Die aktuelle Aktion |
| {Ereignis} | Das aktuelle Ereignis |
| {Typ} | Der aktuelle Pfadtyp (ws,controller,front,api) |
| {Modul} | Das aktuelle Modul (falls Modul aktiv) |
| {Ausweis} | Die aktuelle ID |
| {idparent} | Der aktuelle idparent |
| {Kategorie} | Die aktuelle Kategorie |
| {Unterkategorie} | Die aktuelle Unterkategorie |
| {Unterunterkategorie} | Die aktuelle Unterunterkategorie |
Beispiel:
// controller example http://somedomain/Customer/Insert/23
$ this -> callObjectEx ( ' cocacolacontroller{controller}Controller ' );
// it calls the method cocacolacontrollerCustomer::InsertAction(23,'','');
// front example: http://somedomain/product/coffee/nescafe/1
$ this -> callObjectEx ( ' cocacolacontroller{category}Controller ' // the class to call
, false // if error then it throw an error
, ' {subcategory} ' // the method to call (get, post or any other method)
, null // the method to call (method get)
, null // the method to call (method post)
,[ ' subsubcategory ' , ' id ' ] // the arguments to call the method
,[ ' arg1 ' , ' arg2 ' ]); // arguments that will be passed to the constructor of the instance
// it calls the method cocacolacontrollerproduct::coffee('nescafe','1');Rufen Sie mithilfe der aktuellen Route eine Methode innerhalb eines Objekts auf.
Beispiel:
Router:
$ databaseService = new SomeDatabaseService ();
$ route = new RouteOne ();
$ route -> callObjectEx ( ' cocacolacontroller{controller}Controller ' // the class to call
, false // if error then it throw an error
, ' {action}Action ' // the method to call (get, post or any other method)
, ' {action}Action{verb} ' // the method to call (method get)
, ' {action}Action{verb} ' // the method to call (method post)
,[ ' id ' , ' idparent ' , ' event ' ] // the arguments to call the method
,[ $ databaseService , $ route ]); // (optional)arguments that will be passed to the constructor of the instance Regler:
namespace cocacola controller ;
class CustomerController {
protected $ databaseService ;
protected $ route ;
public function __construct ( $ databaseService , $ route ) {
// optional: injecting services
$ this -> databaseService = $ databaseService ;
$ this -> route = $ route ;
}
// any action GET or POST
public function GreenAction ( $ id = "" , $ idparent = "" , $ event = "" ) {
}
// GET only action (optional)
public function BlueActionGET ( $ id = "" , $ idparent = "" , $ event = "" ) {
// **my code goes here.**
}
// POST only action (optional)
public function YellowActionPOST ( $ id = "" , $ idparent = "" , $ event = "" ) {
// **my code goes here.**
}
// GET only action (optional)
public function RedActionGET ( $ id = "" , $ idparent = "" , $ event = "" ) {
// **my code goes here.**
}
// any action GET or POST
public function RedAction ( $ id = "" , $ idparent = "" , $ event = "" ) {
// **my code goes here.**
}
}Ergebnisse:
| URL | Methode aufgerufen |
|---|---|
| http://localhost/Customer/Green (GET) | GreenAction |
| http://localhost/Customer/Green/20/30?_event=click (GET) | GreenAction($id=20, $idparent=30, $event='click') |
| http://localhost/Customer/Green (POST) | GreenAction |
| http://localhost/Customer/Blue (GET) | BlueActionGET |
| http://localhost/Customer/Blue (POST) | FEHLER |
| http://localhost/Customer/Yellow (GET) | FEHLER |
| http://localhost/Customer/Yellow (POST) | YellowActionPOST |
| http://localhost/Customer/Red (GET) | RedActionGET (Es hat Priorität vor RedAction) |
| http://localhost/Customer/Red (POST) | RedAction |
| http://localhost/Customer/Orange | FEHLER |
Es ruft (include) eine PHP-Datei mit dem aktuellen Namen des Controllers auf
Syntax:
getHeader($key, $valueIfNotFound = null)
Es ruft den aktuellen Header ab (falls vorhanden). Wenn der Wert nicht gefunden wird, wird $valueIfNotFound zurückgegeben. Beachten Sie, dass der $key immer in Großbuchstaben umgewandelt wird.
Beispiel:
$ token = $ this -> getHeader ( ' token ' , ' TOKEN NOT FOUND ' );Syntax:
getBody($jsonDeserialize = false, $asAssociative = true)
Es ruft den Hauptteil einer Anfrage ab.
Beispiel:
$ body = $ this -> getBody (); // '{"id"=>1,"name"=>john}' (as string)
$ body = $ this -> getBody ( true ); // stdClass {id=>1,name=>john}
$ body = $ this -> getBody ( true , true ); // ["id"=>1,"name"=>john]Gibt die aktuelle Basis-URL ohne Leerzeichen, Parameter oder Abfragen zurück
Hinweis : Diese Funktion basiert auf $_SERVER['SERVER_NAME'] und kann vom Endbenutzer geändert werden
Es gibt den aktuellen Server ohne abschließenden Schrägstrich zurück.
$ route -> getCurrentServer (); // http://somedomain Es legt den aktuellen Servernamen fest. Es wird von getCurrentUrl() und getCurrentServer() verwendet.
Hinweis: Wenn $this->setCurrentServer() nicht festgelegt ist, verwendet es $_SERVER['SERVER_NAME'] und kann vom Benutzer geändert werden.
$ route -> setCurrentServer ( ' localhost ' );
$ route -> setCurrentServer ( ' 127.0.0.1 ' );
$ route -> setCurrentServer ( ' domain.dom ' ); Es ruft die (vollständige) URL basierend auf den Informationen in der Klasse ab.
$ route -> getUrl (); // http://somedomain/controller/action/id
$ route -> getUrl ( ' id=20 ' ); // http://somedomain/controller/action/id?id=20
$ route -> getUrl ( ' id=20 ' , true ); // http://somedomain/controller/action/id?id=20&field=20&field2=40Es erstellt eine URL basierend auf benutzerdefinierten Werten
$ route -> url ( null , " Customer " , " Update " , 20 ); // Customer/Update/20Es erstellt eine URL (vorne) basierend auf benutzerdefinierten Werten
$ route -> url ( null , " Daily " , " Milk " , 20 ); // Daily/Milk/20 Wenn die Subdomain leer ist oder sich von www unterscheidet, wird auf www.domain.com umgeleitet.
Hinweis: Es funktioniert nicht mit Localhost, Domains ohne TLD (NetBIOS) oder IP-Domains. Es ist Absicht.
Hinweis: Wenn dieser Code umgeleitet werden muss, stoppt er die Ausführung des Codes. Normalerweise muss es am Anfang des Codes aufgerufen werden
$ route -> alwaysWWW (); // if the domain is somedomain.dom/url, then it redirects to www.somedomain.dom/url
$ route -> alwaysWWW ( true ); // if the domain is http: somedomain.dom/url, then it redirects to https: www.somedomain.dom/url Wenn die Seite als http geladen wird, wird auf https umgeleitet.
Hinweis: Es funktioniert nicht mit Localhost, Domain ohne TLD (NetBIOS) oder IP-Domains. Es ist Absicht.
Hinweis: Wenn dieser Code umgeleitet werden muss, stoppt er die Ausführung des Codes. Normalerweise muss es am Anfang des Codes aufgerufen werden
$ route -> alwaysHTTPS (); // http://somedomain.com ---> https://somedomain.com
$ route -> alwaysHTTPS (); // http://localhost ---> // http://localhost
$ route -> alwaysHTTPS (); // http://127.0.0.1 ---> // http://127.0.0.1
$ route -> alwaysHTTPS (); // http://mypc ---> // http://mypc Wenn die Subdomain www ist (Beispiel www.domain.dom), wird auf eine nackte Domain domain.dom umgeleitet
Hinweis: Es funktioniert nicht mit Localhost, Domains ohne TLD (NetBIOS) oder IP-Domains. Es ist Absicht.
Hinweis: Wenn dieser Code umgeleitet werden muss, stoppt er die Ausführung des Codes. Normalerweise muss es am Anfang des Codes aufgerufen werden
$ route -> alwaysNakedDomain (); // if the domain is www.somedomain.dom/url, then it redirects to somedomain.dom/url
$ route -> alwaysNakedDomain ( true ); // if the domain is http: www.somedomain.dom/url, then it redirects to https: somedomain.dom/url | Feld | Weg | Beschreibung | Beispiel |
|---|---|---|---|
| $argumentName | Der Name des von Apache .Htaccess und nginx verwendeten Arguments | $this-argumentName='req'; | |
| $base | Es ist die Basis-URL. | $this->base=0; | |
| $typ | Es ist der Typ der URL (API, WS, Controller oder Front). | echo $this->type; // API | |
| $module | {Modul} | Es ist das aktuelle Modul | echo $this->module; |
| $controller | {Regler} | Es ist der Controller. | echo $this->controller; |
| $Aktion | {Aktion} | Es ist die Aktion. | echo $this->action; |
| $id | {Ausweis} | Es ist die Kennung | echo $this->id; |
| $event | {Ereignis} | Es ist das Ereignis (z. B. „Klicken Sie auf die Schaltfläche“). | echo$this->event; |
| $idparent | {idparent} | Es ist die aktuelle Eltern-ID (falls vorhanden) | echo $this->idparent; |
| $extra | {Extra} | Es ist das Ereignis (z. B. „Klick auf Schaltfläche“) | echo $this->extra; |
| $kategorie | {Kategorie} | Die aktuelle Kategorie. Es ist nützlich für den Typ „Front“ | echo $this->category; |
| $Unterkategorie | {Unterkategorie} | Die aktuelle Unterkategorie. Es ist nützlich für den Typ „Front“ | echo $this->subcategory; |
| $subsubcategory | {Unterunterkategorie} | Die aktuelle Unter-Unterkategorie. Es ist nützlich für den Typ „Front“ | echo $this->subsubcategory; |
| $identifizieren | Es handelt sich um ein assoziatives Array, das bei der Identifizierung der API- und WS-Route hilft. | $this->identify=['api'=>'apiurl','ws'=>'webservices','controller'=>'']; | |
| $isPostBack | Es ist wahr, wenn die Seite POST ist, andernfalls falsch. | if ($this->isPostBack) { ... }; | |
| $verb | {Verb} | Das aktuelle Verb könnte GET, POST, PUT und DELETE sein. | if ($this->verb) { ... }; |
Beispiel:
$ this -> addPath ( ' portal/web/{controller}/{action:list} ' );
$ this -> fetchPath ();
var_dump ( $ this -action); // it shows the current action or the default value "list" if none. | Feld | Beschreibung | Beispiel |
|---|---|---|
| $allowedVerbs | Eine Liste mit erlaubten Verben | $this->allowedVerbs=['GET', 'POST', 'PUT', 'DELETE']; |
| $allowedFields | Eine Liste mit zulässigen Feldern, die von callObjectEx() verwendet werden | $this->allowedFields=['controller', 'action', 'verb', 'event', 'type', 'module', 'id' , 'idparent', 'category', 'subcategory', 'subsubcategory']; |
| setWhitelist() | Es legt ein assoziatives Array mit der Whitelist für Controller , Aktion , Kategorie , Unterkategorie , Unterunterkategorie und Modul fest. Wenn nicht festgelegt (Null-Standardwert), ist jede Eingabe zulässig. Derzeit funktioniert es nur mit Controller und Kategorie | $this->setWhitelist('controller','Purchase','Invoice','Customer'); $this->setWhitelist('controller',null) // erlaubt jeden Controller; |
Das Whitelisting einer Methode ermöglicht zwei Vorgänge:
Zum Beispiel:
// Example, value not in the whitelist: someweb.dom/customer/list
$ this -> setWhiteList ( ' controller ' ,[ ' Product ' , ' Client ' ]);
$ this -> fetch ();
var_dump ( $ this -> controller ); // null or the default value
var_dump ( $ this -> notAllowed ); // true (whitelist error)
// Example, value in the whitelist but with the wrong case: someweb.dom/customer/list
$ this -> setWhiteList ( ' controller ' ,[ ' Customer ' ]);
$ this -> fetch ();
var_dump ( $ this -> controller ); // it shows "Customer" instead of "customer"
var_dump ( $ this -> notAllowed ); // false (not error with the validation of the whitelist)
// reset whitelist for controllers
$ this -> setWhiteList ( ' controller ' , null ); RouteOne enthält eine grundlegende CLI zum Erstellen und Initialisieren der Konfiguration. Die binäre RouteOne CLI befindet sich im Ordner „vendor/bin“.
./vendor/bin/ RouteOne cliGeben Sie „Router“ ein und drücken Sie die Eingabetaste.
Im Router-Menü wird der nächste Bildschirm angezeigt:
„Ausstehend“ bedeutet, dass die Ausführung des Vorgangs aussteht oder dass etwas konfiguriert werden muss.
Sobald die Konfiguration abgeschlossen ist, wird sie mit „OK“ markiert.
Jetzt konfigurieren wir die Pfade
