9 - Authentification JWT (non testé et non terminé probablement)

composer require lexik/jwt-authentication-bundle
php bin/console lexik:jwt:generate-keypair

dans security.yaml :
firewalls:
	login:
		pattern:  ^/api/login
            	stateless: true
            	anonymous: true
            	json_login:
               		check_path:               /api/login_check
                	success_handler: lexik_jwt_authentication.handler.authentication_success
                	failure_handler: lexik_jwt_authentication.handler.authentication_failure






https://www.youtube.com/watch?v=BhXFvTqByeQ
dans ma ressource :
itemOperations: [
	'put', 'delete', ..., 
	'monaction' => [
		'method' => 'POST',
		'path' => '/entity/{id}/monaction',
		'controller' => PostMonactionController::class,
		'read' => false (ou true si besoin),
		'pagination_enabled' => false,
		'filters' => [],
		'openapi_context' => [
			'summary' => 'Récupère ...',
			'parameters' => [
				'in' => 'query',
				'name' => 'un nom',
				'schema' => [
					'type' => 'integer',
					'maximum' => 1,
					'minimum' => 0
				],
				'description' => 'Filtre ...'
			],
			'responses' => [
				'200' => [
					'description' => 'OK',
					'content' => [
						'application/json' => [
							'schema' => [
								'type' => 'integer',
								'example' =>3
 							]
						]
					]
				]
			]
		]
	]
]

Dans src/Controller, créer un ficher PostMonactionController.php :
<?php
namespace App\Controller;
use App\Entity\Post;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;

class PostMonactionController extends AbstractController
{
	public function __invoke(Post $data, Request $request): Post
	{
		$data->setOnline(true);	//Ajouter la logique
		return $data;
	}
}

// Avec l'ancienne écriture :
 *          "image"= {
 *              "method" = "POST",
 *              "path" = "/products/{id}/image",
 *              "deserialize" = false,
 *              "security_post_denormalize" = "is_granted('ROLE_SELLER')" ,
 *              "denormalizationContext" = {"groups"={"write"}},
 *              "controller" = ProductImageController::class,
 *              "openapi_context" = {
 *                  "requestBody" = {
 *                      "content" = {
 *                          "multipart/form-data" = {
 *                              "schema" = {
 *                                  "type" = "object",
 *                                  "properties" = {
 *                                      "file" = {
 *                                          "type" = "string",
 *                                          "format" = "binary"
 *                                      }
 *                                  }
 *                              }
 *                          }
 *                      }
 *                  }
 *              }
 *          }

5 - Opérations personnalisées

// [Tutoriel API Platform : Envoi de fichiers - YouTube](https://www.youtube.com/watch?v=fhdD7K5nZSA)

// Créer un point d'entrée
// Entity post.php
'image'= {
  "method" = "POST",
  "path" = "/post/{id}/image",
  "deserialize" = false,
  "controller" = PostImageController::class,
  "openapi_context" = {
    "requestBody" = {
      "content" = {
        "multipart/form-data" = {
          "schema" = {
            "type" = 'object',
            "properties" = {
              "file" = {
                "type" = 'string',
                "format" = 'binary'
              }
            }
          }
        }
      }
    }
  }
}

// Créer la requête mutipart/form dans Postman(optionnel)

// Créer un controlleur PostImageController.php

namespace App\Controller;

use App\Entity\Post;
use Symfony\Component\HttpFoundation\Request;
class PostImageController {
  public function __invoke(Post $post, Request $request){
    $post = $request->attributes->get('data');
    if(!($post instanceof Post)){
      throw new \RuntimeException("nécessite un Post")
    }
    $file= $request->files->get('file');
    $post->setFile($request->files->get('file'));
    $post->setUpdatedAt(new \DateTime());
    return $post;
  }
}

// Dans api_platform.yaml, ajouter les formats manquants
api_platform:
    formats:
    // ou bien ?
    format: 
        json:     ['application/json']
        jsonld:   ['application/ld+json']
        html:     ['text/html']
        multipart:['multipart/form-data']
    patch_formats:
        json:       ['application/merge-patch+json']

// Créer un champ filePath dans l'entity Post (nullable) + faire la migration
        
// Ajouter le bundle d'upload de fichier et executer la recette
composer require vich/uploader-bundle

// Dans le fichier vich_uploader.yaml, décommenter les lignes :
vich_uploader:
    db_driver: orm
    mappings:
        post_image:
          uri_prefix: /images/posts
          upload_destination: '%kernel.project_dir%/public/images/posts'
          namer: Vich\UploaderBundle\Naming\OrignameNamer

// Dans entity Post :
use Symfony\Component\HttpFoundation\File\File;
use Vich\UploaderBundle\Mapping\Annotation\Uploadable;
use Vich\UploaderBundle\Mapping\Annotation as Vich;

 //Ajouter (à ne pas oublier, c'est fréquent...)
 * @Vich\Uploadable()

// Modifier l'entity
 class Post{
  /**
   * @var File|null
   * @Vich\UploadableField(mapping="post_image", fileNameProperty="filePath")
   */
   private $file;
   
   /**
    * @ORM...
    */
    private $filePath;
   
   /**
    * @return File|null
    */
    public function getFile(): ?File
    {
      return $this->file;
    }
    
   /**
    * @return File|null $file
    * @return Post
    */
    public function setFile(?File $file): Post
    {
      $this->file = $file;
      return $this;
    } 
 }
 
 // Dans le même fichier ajouter une nouvelle propriété pour avoir un chemin plus exploitable
 /**
  * @var string|null
  */
  @{Groups({'read:collection'})}
  private $fileUrl;
// ajouter getter et setter

// Afin d'hydrater ce champs, créer un normalizer dans Serializer/PostNormalizer.php
// Ne sera pas utilisé si "deserialise" = false dans l'entity
namespace App\Serializer;

use Symfony\Component\Security\Core\Security;
use Symfony\Component\Serializer\Normalizer\ContextAwareDenormalizerInterface;
use Vich\UploaderBundle\Storage\StorageInterface;

class PostNormalizer implements ContextAwareDenormalizerInterface, DenormalizerAwareInterface
{
    use NormalizerAwareTrait;
    private const ALREADY_CALLED = 'AppPostNenormalizerAlreadyCalled';

    public function __construct(StorageInterface $storage){

    }

    public function supportsNormalization($data, string $format = null, array $context = []){
        return !isset($context[self::ALREADY_CALLED]) && $data instanceof Post;
    }

    public function Normalize($object, string $format = null, array $context = []){
        $object->setFileUrl($this->storage->resolveUri($object, 'file'));
        $context[self::ALREADY_CALLED] = true;
        return $this->normalizer->normalize($object, $format, $context);
    }

}
 




Envoyer des fichiers

dans la ressource, mettre :
	paginationItemsPerPage : 2,
	paginationMaximumItemsPerPage :2,

Les filtres permettent de faire une recherche sur une entité sur une autre propriété que l'id. 
Après la ressource, au dessus de la classe :
 * @ApiFilter(SearchFilter::class, properties={
 *     "slug": "exact"
 * })


4 - Pagination et filtres

// [Tutoriel API Platform : Désérialiser du multipart - YouTube](https://www.youtube.com/watch?v=K8iVhRvjPoM)
// Pour pouvoir ajouter d'autres informations lors de l'envoie

// Créer un point d'entrée
// Entity post.php ("deserialize"=true, a été enlevé ici)
'image'= {
  "method" = "POST",
  "path" = "/post/{id}/image",
  "controller" = PostImageController::class,
  "openapi_context" = {
    "requestBody" = {
      "content" = {
        "multipart/form-data" = {
          "schema" = {
            "type" = 'object',
            "properties" = {
              "file" = {
                "type" = 'string',
                "format" = 'binary'
              }
            }
          }
        }
      }
    }
  }
}

// Créer la requête mutipart/form dans Postman(optionnel)

// Créer un controlleur PostImageController.php

namespace App\Controller;

use App\Entity\Post;
use Symfony\Component\HttpFoundation\Request;
class PostImageController {
  public function __invoke(Post $post, Request $request){
    $post = $request->attributes->get('data');
    if(!($post instanceof Post){
      throw new \RuntimeException("nécessite un Post")
    }
    $file= $request->files->get('file');
    $post->setFile($request->files->get('file'));
    $post->setUpdatedAt(new \DateTime());
    return $post;
  }
}

// Dans api_platform.yaml, ajouter les formats manquants
api_platform:
    formats:
        json: ['application/json']
        jsonld: ['application/ld+json']
        html: ['text/html']
        multipart: ['multipart/form-data']
    patch_formats:
        json: ['application/merge-patch+json']

// Créer un champ filePath dans l'entity Post (nullable) + faire la migration
        
// Ajouter le bundle d'upload de fichier et executer la recette
composer require vich/uploader-bundle

// Dans le fichier vich_uploader.yaml, décommenter les lignes :
vich_uploader:
    db_driver: orm
    mappings:
        post_image:
          uri_prefix: /images/posts
          upload_destination: '%kernel.project_dir%/public/images/posts'
          namer: Vich\UploaderBundle\Naming\OrignameNamer

// Dans entity Post :
  use Sumfony\Component/HttpFoundation/File/File
 * @Vich\Uploadable()
 class Post{
  /**
   * @var File|null
   * @Vich\UploadableField(mapping="post_image", fileNameProperty="filePath")
   */
   private $file;
   
   /**
    * @ORM...
    */
    private $filePath;
   
   /**
    * @return File|null
    */
    public function getFile(): ?File
    {
      return $this->file;
    }
    
   /**
    * @return File|null $file
    * @return Post
    */
    public function setFile(?File $file): Post
    {
      $this->file = $file;
      return $this;
    } 
 }
 
 // Dans le même fichier ajouter une nouvelle propriété pour avoir un chemin plus exploitable
 /**
  * @var string|null
  */
  @{Groups({'read:collection'})}
  private $fileUrl;
// ajouter getter et setter

// Afin d'hydrater ce champs, créer un normalizer dans Serializer/PostNormalizer.php
namespace App\Serializer;

use Symfony\Component\Security\Core\Security;
use Symfony\Component\Serializer\Normalizer\ContextAwareDenormalizerInterface;

class PostNormalizer implements ContextAwareDenormalizerInterface, DenormalizerAwareInterface
{
    use NormalizerAwareTrait;
    private const ALREADY_CALLED = 'AppPostNenormalizerAlreadyCalled';

    public function __construct(StorageInterface $storage){

    }

    public function supportsNormalization($data, string $format = null, array $context = []){
        return !isset($context[self::ALREADY_CALLED]) && $data instanceof Post;
    }

    public function Normalize($object, string $format = null, array $context = []){
        $object->setFileUrl($this->storage->resolveUri($object, 'file'));
        $context[self::ALREADY_CALLED] = true;
        return $this->normalizer->normalize($object, $format, $context);
    }

}
---------------------------------------------------------
// Créer un eventListener dans EventListener/DeserializeListener.php

namespace App\EventListener;
use ApiPlatform\Core\EventListener/DeserializeListener as DecoratedListener;

class DeserializeListener{
  public function __construct(DecoratedListener $decorated, SerializerContextBuilderInterface $serializerContextBuilder, DenormalizerInterface $denormalizer){
  
  }
  public fonction onKernelRequest(RequestEvent $event): void
  {
    $request = $event->getRequest();
    if($request->isMethodCacheable() || $request->isMethod(Request::METHOD_DELETE)){
      return;
    }
    if($request->getContentType() === 'multipart'){
        $this->denormalizeFromRequest($request)
    }else{
        $this->decorated->onKernelRequest($event)
    }
    
  }
  
  private function denormalizeFromRequest($Request $request):void
  {
      $attributes = RequestAttributesExtractor::extractAttributes($request);
      if(empty($attributes)){
          return;
      }
      $context = $this->serializerContextBuilder->createFromRequest($request, false, $attributes);
      $populated = $request->attributes->get('data');
      if($populated !== null){
        $context['object_to_populate'] = $populated;
      }
      $data = $request->request->all();
      $files = $request->files->all();
      $object = $this->denormalizer->denormalize(
        array_merge($data, $files),
        $attributes['ressource_class'],
        null,
        $context
      )
      $request->attributes->set('data', $object);
  }
}

// Dans services.yaml, ajouter le deserializer:
App\EventListener\DeserializeListener:
    tags:
        - {name: 'kernel.event_listener', event: 'kernel.request', method: 'onKernelRequest', priority: 2}
    decorates: 'api_platform.listener.request.deserialize'
    autoconfigure: false
    
// Ajouter une denormalisation sur la propriété $file de l'entity
@{Groups({'write:Post'})}
private $file;
// -> une erreur se créé : Cannot use object of type ... as array
// -> désactiver la normalization du UserOwnedDenormalizer.php
public function supportsDenormalization(...){
    return false;
    ...
}

// Une erreur est toujours présente : The provided data URI is not valid
// -> pour solutionner ça, on va devoir créer un fichier pour gérer différemment la dénormalisation des fichiers
// -> dans Serializer/FileDenormalizer.php

namespace App\Serializer;

use Symfony\Component\HttpFoundation\File\File;
use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;

class FileDenormalizer implements DenormalizerInterface{
    public function denormalize($data, string $type, string $format = null, array $context = []){
        return $data;
    }
    
    public function supportsDenormalization($data, string $type, string $format = null){
        return $data instanceof File;
    }
}

// Dans Post.php, le controlleur utilisé actuellement ne sera plus utile et peut être enlevé. Il doit cependant être remplacé par un controlleur (même s'il ne sert à rien). On peut donc y mettre un emptyControlleur qui ne fait aucune logique :
'controller' = EmptyController::class,

// Il faut donc le créer dans Controller/EmptyController.php
namespace App\Controller;
class EmptyController{
    public function __invoke($data$){
        return $data;
    }
}
// Avec ça, Api Platform sera content et nous emmerdera pas.

    
    
    
    
    
    
    
    
    


Envoyer des fichiers 2

[Découverte d'API Platform : Authentification JSON - YouTube](https://www.youtube.com/watch?v=bewgb9buIfI
-Créer user : php bin/console make:user
info : créer un MdP haché : php bin/console security:encode-password
-Faire les migrations nécessaires
-Dans le fichier security.yaml, préciser :
firewalls:
	main:
		json_login:
			check_path : /api/api_login

-Créer un controller SecurityController.php :
namespace App\Controller;
use Symfony\bundle\FrameworkBundle\Controller\AbstractController;
class SecurityController extends AbstractController{
	#[Route(path: 'api/login', name: 'api_login', methods: ['POST'])]
	public function login(){
		$user = $this->getUser();
		return $this->json([
			'username' => $user->getUsername(),
			'roles' => $user->getRoles()
		]);
	}
}

-Créer un point d'entrée privé, dans la ressource (ici User) :
#[ApiResource(
	collectionOperations: [
		'me' => [
			'pagination_enabled' => false,
			'path' => '/me',
			'method' => 'get',
			'controller' => MeController::class,
			'read' => false,
			'security' => 'is_granted("ROLE_USER")'
//			ou bien
			'openapi_context' => [
				'security' => ['cookieAuth' => []]
			]
		]
	],
	itemOperations: [
		'get' => [
			'controller' => NotFoundAction::class,
			'openapi_context' => ['summary' => 'hidden'],
			'read' => false,
			'output' => false
		]
	],
	normalizationContext: ['groups' => ['read:User']]
)]

-Ajouter les groups aux propriétés voulues :
#[Groups('read:user')]

-Créer un controller pour récupérer les informations, ici ce sera MeController.php :
namespace App\Controller;
class MeController
{
	public function __construct(private Security $security)
	{
		
	}
	public function __invoke()
	{
		$user = $this->security->getUser();
		return $user;
	}
}

Fonction Logout :
Dans SecurityController.php :
#[Route(path: '/api/logout', name: 'api_logout', methods: ['POST'])]
public function logout(){}

Dans security.yaml :
json_login:
	check_path: api_login
logout:
	path: api_logout

Créer un logout subscriber si besoin (YT : 23:55)
)

8 - Authentification JSON

10 - Créer de nouvelles routes avec OpenApi, ici pour y ajouter un login JWT

Dans le fichier services.yaml, ajouter la classe qui va décorer et overrider l'openapi :
services:
    App\OpenApi\OpenApiFactory:
        decorates: 'api_platform.openapi.factory'
        arguments: ['@App\OpenApi\OpenApiFactory.inner']
        autoconfigure: true

Créer le fichier OpenApiFactory dans un dossier src/OpenApi et y mettre le code :
<?php

namespace App\OpenApi;


use ApiPlatform\Core\OpenApi\Model;
use ApiPlatform\Core\OpenApi\OpenApi;
use ApiPlatform\Core\OpenApi\Model\PathItem;
use ApiPlatform\Core\OpenApi\Model\Operation;
use ApiPlatform\Core\OpenApi\Model\RequestBody;
use ApiPlatform\Core\OpenApi\Factory\OpenApiFactoryInterface;

class OpenApiFactory implements OpenApiFactoryInterface{
    public function __construct(OpenApiFactoryInterface $decorated) {
        $this->decorated = $decorated;
    }

    public function __invoke(array $context = []): OpenApi
    {
        $openApi = $this->decorated->__invoke($context);
        $schemas = $openApi->getComponents()->getSchemas();

        $schemas['bearerAuth'] = new \ArrayObject([
            'type' => 'object',
            'scheme' => 'bearer',
            'bearerFormat' => 'JWT'
        ]);
        $schemas['Credentials'] = new \ArrayObject([
            'type' => 'object',
            'properties' => [
                'email' => [
                    'type' => 'string',
                    'example' => 'johndoe@example.com',
                ],
                'password' => [
                    'type' => 'string',
                    'example' => 'apassword',
                ],
            ],
        ]);

        $pathItem = new PathItem(
            'JWT Token',                // ref (string)
            'summary',                  // summary (string)
            null,                       // description (string)
            new Operation(              // Operation (object)
                'postCredentialsItem',  // operation-id (string unique)
                ['Token'],              // tags (array)
                [                       // responses (array)
                    '200' => [
                        'description' => 'Get JWT token',
                        'content' => [
                            'application/json' => [
                                'schema' => [
                                    '$ref' => '#/components/schemas/Token',
                                ],
                            ],
                        ],
                    ],
                ],
                'Get JWT token to login.',  // summary (string)
                'description',              // description (string) 
                null,                       // ExternalDocumentation (object)
                [],                         // parameters (array) 
                new RequestBody(            // RequestBody (object)
                    'Generate new JWT Token',   // description (string)
                    new \ArrayObject([          // $content (arrayObject)
                        'application/json' => [
                            'schema' => [
                                '$ref' => '#/components/schemas/Credentials',
                            ],
                        ],
                    ]),
                    // other options : $required (bool)
                ),
                // other options : ArrayObject $callbacks, $deprecated (bool), ?array $security, ?array $servers
            ),
        );
        $openApi->getPaths()->addPath('/authentication_token', $pathItem);

        return $openApi;
    }
        

}

Dans la propriété :
#[
	Length(min: 5, groups: ['create:Post'])
]

dans la ressource, préciser dans collection ou item :
	'post' => [
		'validation_groups' => ['create:Post']
	]

Autoriser la persistance en cascade :
Cela se fait dans la l'annotation ORM :
@ORM/ManyToOne (targetEntity=... , cascade="persist")
#[
	Groups(...),
	Valid()
]


3 - Validation

Pour sélectionner les données à montrer et à cacher.
A placer dans la propriété : 
* @Groups({"read", "write","read:product:item", "read:seller:item"})

Dans la ressource :
/**
 * @ApiResource( 
        // Pour obtenir une liste, utiliser une collection
        // Get et post only
        // image est une route supplémentaire
 *     collectionOperations={
 *          "get"= {
 *              "security"="is_granted('ROLE_SELLER')"
 *          },
 *          "post" = { 
 *              "security_post_denormalize" = "is_granted('ROLE_SELLER')" ,
 *              "denormalizationContext" = {"groups"={"write"}}
 *          },
 *          "image"= {
 *              "method" = "POST",
 *              "path" = "/products/{id}/image",
 *              "deserialize" = false,
 *              "security_post_denormalize" = "is_granted('ROLE_SELLER')" ,
 *              "denormalizationContext" = {"groups"={"write"}},
 *              "controller" = ProductImageController::class,
 *              "openapi_context" = {
 *                  "requestBody" = {
 *                      "content" = {
 *                          "multipart/form-data" = {
 *                              "schema" = {
 *                                  "type" = "object",
 *                                  "properties" = {
 *                                      "file" = {
 *                                          "type" = "string",
 *                                          "format" = "binary"
 *                                      }
 *                                  }
 *                              }
 *                          }
 *                      }
 *                  }
 *              }
 *          }
 *     },
       // Pour obtenir détails sur un élément
       // Méthodes get, patch et delete only
 *      itemOperations= {
 *          "get"= {
 *              "normalization_context"= {
 *                  "groups"= {"read:product:item"}
 *              }
 *          },
 *          "patch"= {
 *              "security"="is_granted('ROLE_SELLER')",
 *              "denormalizationContext" = {"groups"={"write"}}
 *          },
 *          "delete"= {
 *              "security"="is_granted('ROLE_SELLER')",
 *              "denormalizationContext" = {"groups"={"write"}}
 *          },
 *      }
 * )
    // On peut aussi filter selon un autre critère
    // Ici on peut utiliser l'id mais aussi la propriété slug : 
 * @ApiFilter(SearchFilter::class, properties={
 *      "id": "exact",
 *      "slug": "exact"
 * })
 * @ORM\Entity(repositoryClass=ProductRepository::class)
 * @Vich\Uploadable()
 */
 
-----> Attention : penser à vider le cache si pas de résultat !!!

-----> Note : Différence relou entre normalization et denormalization. Tester en cas de doute.
"get"= {
    "normalization_context" = {"groups"={"read"}}
},
"patch"= {
    "denormalizationContext" = {"groups"={"write"}}
},

2 - Sérialisation

Créer une entity qui représentera l'objet
-Ajouter la ressource:
@ApiRessource("itemOperations"={"get"},"collectionOperations"={"get"})
-Ajouter la propriété qui sert à l'identification :
@ApiProperty(identifier=true)
-On peut décrire les autres propriétés avec :
@ApiProperty(description="nom de la description")
-Créer le dataProvider dans dossier DataProvider :
namespace A\DataProvider;
class ChoosenNameDataProvider implements CollectionDataProviderInterface, ItemDataProviderInterface,  RestrictedDataProviderInterface{
	public function getCollection(){}
	public function supports(){}
	public function getItem(){}
}


6 - DataProvider

on travaille sur l'entity Dependency
<§
class DependencyDataPersister implements DataPersisterInterface{
	protected $em;
	public function __construct(EntityManagerInterface $em){
		$this->em = $em;
	}
	public function supports($data){
		return $data instanceof Dependency;
	}
	public function persist($data){
		// Ajouter le logique qu'on veut persister
		$this->em->persist($data);
		$this->em->flush();
	}
	public function remove(){
		$this->em->remove($data);
		$this->em->flush();
	}
}
§>

7 - DataPersister

Au dessus de la classe d'une entité :
@ApiRessource() 

Pour faire les associations entre entity, ne pas utiliser directement l'id mais "/api/category/{id}"


API Platform