In dieser Lektion erfahren Sie, wie Sie schnell eine RESTful-API für eine beliebige Site auf einem beliebigen CMS erstellen. MODX ist nur ein Beispiel.
Um die API zu erstellen, verwende ich:
Das Ergebnis ist hier:
https://github.com/andchir/modx2-api
Ich habe alles unter Linux beschrieben, aber ich denke, dass der Unterschied bei den Befehlen unter Windows nicht groß sein wird. Ich habe Composer und das Symfony- Dienstprogramm vorinstalliert.
Erstellen eines Projekts und von Benutzerklassen
Ich erstelle ein Projekt:
composer create-project symfony/skeleton modx2-api
Installieren Sie die erforderlichen Pakete, um die API zu erstellen:
cd modx2-api composer req api composer req migrations composer req form composer req maker --dev
Ich starte den lokalen Server.
Wenn das Symfony-Dienstprogramm installiert ist:
symfony server:start
oder so:
php -S 127.0.0.1:8000 -t public
Ich öffne die Adresse im Browser, um zu überprüfen, ob alles funktioniert:
http://127.0.0.1:8000/
Ich öffne die .env- Datei und bearbeite die Verbindungszeichenfolge zur Projektdatenbank auf MODX :
DATABASE_URL=mysql://db_user:db_password@127.0.0.1:3306/db_name
Nun müssen Sie einen Benutzer anlegen und das Autorisierungssystem mit Login und Passwort konfigurieren.
Installieren Sie zusätzliche Pakete:
composer req jwt-auth composer req orm-fixtures --dev composer req profiler --dev
In der ENV- Datei wurden neue Optionen für das JVT -Authentifizierungspaket angezeigt .
Ich erstelle die Entity- und Repository-Klassen (Doctrine ORM) des Benutzers:
php bin/console make:user
Es erschienen zwei Dateien:
src/Entity/User.php src/Repository/UserRepository.php
Ich erstelle die Tabelle "Benutzer" in der Datenbank:
bin/console doctrine:schema:create
Ich konfiguriere die Benutzerberechtigung gemäß den Anweisungen:
Controller Code App \ Controller \ SecurityController <?php namespace App\Controller; use App\Entity\User; use App\Form\Type\LoginType; use App\Form\Type\UpdateProfileType; use Doctrine\ORM\EntityManagerInterface; use Symfony\Bundle\FrameworkBundle\Controller\AbstractController; use Symfony\Component\HttpFoundation\Request; use Symfony\Component\HttpFoundation\Response; use Symfony\Component\Routing\Annotation\Route; use Symfony\Component\Security\Core\Encoder\UserPasswordEncoderInterface; use Symfony\Component\Security\Http\Authentication\AuthenticationUtils; use Symfony\Component\Validator\Validator\ValidatorInterface; class SecurityController extends AbstractController { public function loginAction(AuthenticationUtils $authenticationUtils): Response { if ($this->getUser()) { return $this->redirectToRoute('api_entrypoint'); } $form = $this->createForm(LoginType::class); $error = $authenticationUtils->getLastAuthenticationError(); $lastUsername = $authenticationUtils->getLastUsername(); return $this->render('security/login.html.twig', [ 'form' => $form->createView(), 'last_username' => $lastUsername, 'error' => $error ]); } }
Ich erstelle eine Klasse zum Anlegen von Benutzern:
php bin/console make:fixtures
Weitere Informationen finden Sie hier: https://symfony.com/doc/current/security.html#a-create-your-user-class
Klassencode App \ DataFixtures \ UserFixtures <?php namespace App\DataFixtures; use App\Entity\User; use Doctrine\Bundle\FixturesBundle\Fixture; use Doctrine\Common\Persistence\ObjectManager; use Symfony\Component\Security\Core\Encoder\UserPasswordEncoderInterface; class UserFixtures extends Fixture { private $passwordEncoder; public function __construct(UserPasswordEncoderInterface $passwordEncoder) { $this->passwordEncoder = $passwordEncoder; } public function load(ObjectManager $manager) { $user = new User(); $user ->setEmail('admin@admin.com') ->setRoles(['ROLE_USER', 'ROLE_ADMIN']); $user->setPassword($this->passwordEncoder->encodePassword( $user, 'admin'
Ich erstelle einen Administrator mit der E-Mail-Adresse "admin@admin.com" und dem Passwort "admin" :
php bin/console doctrine:fixtures:load --append --group=UserFixtures
Später können diese Daten geändert werden.
Ich generiere die Schlüssel im Ordner config / jwt / :
jwt_passhrase=$(grep ''^JWT_PASSPHRASE='' .env | cut -f 2 -d ''='') echo "$jwt_passhrase" | openssl genpkey -out config/jwt/private.pem -pass stdin -aes256 -algorithm rsa -pkeyopt rsa_keygen_bits:4096 echo "$jwt_passhrase" | openssl pkey -in config/jwt/private.pem -passin stdin -out config/jwt/public.pem -pubout setfacl -R -mu:www-data:rX -mu:"$(whoami)":rwX config/jwt setfacl -dR -mu:www-data:rX -mu:"$(whoami)":rwX config/jwt
Überprüfung der Erstellung des Tokens:
curl -X POST -H "Content-Type: application/json" http://localhost:8000/authentication_token -d '{"email":"admin@admin.com","password":"admin"}'
Ich erstelle eine Migration:
php bin/console make:migration
Nun der lustige Teil.
API- und Dokumentationserstellung
Ich generiere Entitätsklassen für alle Datenbanktabellen:
php bin/console doctrine:mapping:import "App\Entity" annotation --path=src/Entity
Ich generiere Getter und Setter für Klassen:
php bin/console make:entity --regenerate App
Ich öffne den Code einer Klasse, zum Beispiel src / Entity / ModxSiteContent.php . Fügen Sie die Annotation @ApiResource hinzu :
Die API für ModxSiteContent ist bereit.
Ich öffne die Seite http: // localhost: 8000 / api
Ich nehme den Token, klicke auf "Autorisieren" und füge die Zeile mit dem Token ein:
Bearer MY_TOKEN
Ich klicke auf die Schaltfläche "Ausprobieren" und dann auf die Schaltfläche "Ausführen" . Ich bekomme dieses Ergebnis:
Tabellenbeziehungen
Ich werde nicht beschreiben, wie Filter erstellt werden, um die Dokumentation nicht zu duplizieren, aber ich werde ein Beispiel dafür geben, wie Sie Beziehungen für Tabellen erstellen können, weil es ist ein bisschen kniffliger.
Bei MODX werden Benutzerdaten in einer separaten Tabelle "user_attributes" gespeichert. Zum Beispiel muss ich die E-Mail-Adresse, den Namen, die Telefonnummer usw. auf Anforderung von GET zu einer Stichprobe von Benutzern hinzufügen. Ich öffne den Klassencode App \ Entity \ ModxUsers , füge die Privateigenschaft $attributes und beschreibe die Verbindung mit der Klasse App \ Entity \ ModxUserAttributes in der Annotation "@ORM \ OneToOne":
private $attributes;
Wieder füge ich die fehlenden Getter und Setter hinzu:
php bin/console make:entity --regenerate App\\Entity\\ModxUsers
Bitte beachten Sie, dass ich die Gruppe "Attribute" zur Annotation @ApiResource
Ich öffne den Code der Klasse App \ Entity \ ModxUserAttributes , füge die Annotation @ApiResource und die Verbindung mit der Klasse App\Entity\ModxUsers :
private $user;
Zu allen Eigenschaften, die zur Auswahl hinzugefügt werden müssen, @Groups({"attributes"}) ich die Anmerkung @Groups({"attributes"}) .
Ergebnis:
Daher müssen Sie für die Autorisierung in Ihrer Anwendung zunächst ein Login (E-Mail) und ein Passwort an die URL "/ authentication_token" senden, ein Token abrufen und dieses Token dann in jeder Anforderung im Header "Authorization" senden:
Wenn das Projekt https://github.com/andchir/modx2-api für Benutzer interessant ist, wird es sich entwickeln. Ich warte auch auf PR von allen, die helfen wollen.