Tweet
Tweet

Slide 1

Slide 1 text

Resource Revolution on the new Sylius Resource & Grid

Slide 2

Slide 2 text

Loïc Frémont Technical Expert @Akawaka Core Team Member @Sylius Monofony creator

Slide 3

Slide 3 text

1. Resource Revolution 2. Akawaka 3. What is Monofony and Why use it? 4. New Sylius Resource System 5. Sylius Resource without driver 6. What’s next?

Slide 4

Slide 4 text

Akawaka Experts for your web projects & Sylius partner We help you design and improve your projects:

Slide 5

Slide 5 text

Akawaka Experts for your web projects & Sylius partner We help you design and improve your projects: We use clean architecture techniques via DDD methodologies for projects that stand the test of time,

Slide 6

Slide 6 text

Akawaka Experts for your web projects & Sylius partner We help you design and improve your projects: We use clean architecture techniques via DDD methodologies for projects that stand the test of time, A true quality approach through testing,

Slide 7

Slide 7 text

Akawaka Experts for your web projects & Sylius partner We help you design and improve your projects: We use clean architecture techniques via DDD methodologies for projects that stand the test of time, A true quality approach through testing, Efficient industrialization adapted to your projects,

Slide 8

Slide 8 text

Akawaka Experts for your web projects & Sylius partner We help you design and improve your projects: We use clean architecture techniques via DDD methodologies for projects that stand the test of time, A true quality approach through testing, Efficient industrialization adapted to your projects, On a contract or fixed-price basis, to create and/or integrate teams and work in complete collaboration.

Slide 9

Slide 9 text

What is Monofony and Why use it?

Slide 10

Slide 10 text

What is Monofony and Why use it? Bootstrapping a modern application on top of Symfony

Slide 11

Slide 11 text

What is Monofony and Why use it? Bootstrapping a modern application on top of Symfony Leveraging Sylius bundles and components

Slide 12

Slide 12 text

What is Monofony and Why use it? Bootstrapping a modern application on top of Symfony Leveraging Sylius bundles and components Helping you to focus more on what truly matters to your use-case

Slide 13

Slide 13 text

Installation $ composer create-project monofony/skeleton project_name

Slide 14

Slide 14 text

No content

Slide 15

Slide 15 text

No content

Slide 16

Slide 16 text

Monofony API Pack voir l’installation détaillée dans la doc. $ composer require monofony/api-pack "^0.10"

Slide 17

Slide 17 text

No content

Slide 18

Slide 18 text

Resource Bundle

Slide 19

Slide 19 text

Past use cases

Slide 20

Slide 20 text

Past use cases Making CRUD with Doctrine entities.

Slide 21

Slide 21 text

Past use cases Making CRUD with Doctrine entities. Avoiding writing controllers that all do the same things.

Slide 22

Slide 22 text

Today use cases

Slide 23

Slide 23 text

Today use cases Better DX

Slide 24

Slide 24 text

Today use cases Better DX Customize persistence layer : ERP, Elastic search…

Slide 25

Slide 25 text

Today use cases Better DX Customize persistence layer : ERP, Elastic search… Allow to use in DDD projects

Slide 26

Slide 26 text

New Sylius Resource System

Slide 27

Slide 27 text

New Sylius Resource System API Platform for the inspiration

Slide 28

Slide 28 text

New Sylius Resource System API Platform for the inspiration Akawaka & Commerce Weavers for sponsoring that development

Slide 29

Slide 29 text

New Sylius Resource System API Platform for the inspiration Akawaka & Commerce Weavers for sponsoring that development Łukasz Chruściel at Commerce Weavers for the code reviews

Slide 30

Slide 30 text

Configure your main templates dir # config/package/sylius_resource.yaml sylius_resource: settings: default_templates_dir: '@SyliusAdminUi/crud'

Slide 31

Slide 31 text

Use the Resource attribute PHP attribute #[AsResource] configures your entity as a Sylius resource. ` ` namespace App\Entity; use App\Repository\BookRepository; use Doctrine\ORM\Mapping as ORM; use Sylius\Resource\Metadata\AsResource; use Sylius\Resource\Model\ResourceInterface; #[ORM\Entity(repositoryClass: BookRepository::class)] #[AsResource] class Book implements ResourceInterface { }

Slide 32

Slide 32 text

Use the Resource attribute PHP attribute #[AsResource] configures your entity as a Sylius resource. ` ` #[AsResource] namespace App\Entity; use App\Repository\BookRepository; use Doctrine\ORM\Mapping as ORM; use Sylius\Resource\Metadata\AsResource; use Sylius\Resource\Model\ResourceInterface; #[ORM\Entity(repositoryClass: BookRepository::class)] class Book implements ResourceInterface { }

Slide 33

Slide 33 text

Use the Resource attribute PHP attribute #[AsResource] configures your entity as a Sylius resource. ` ` use Sylius\Resource\Metadata\AsResource; #[AsResource] namespace App\Entity; use App\Repository\BookRepository; use Doctrine\ORM\Mapping as ORM; use Sylius\Resource\Model\ResourceInterface; #[ORM\Entity(repositoryClass: BookRepository::class)] class Book implements ResourceInterface { }

Slide 34

Slide 34 text

Debug command Output bin/console sylius:debug:resource 'app.book' New Resource Metadata --------------------- ------------------------ ------------------- Option Value ------------------------ ------------------- alias "app.book" section null formType null templatesDir null routePrefix null name "book" pluralName null applicationName "app" identifier null normalizationContext null denormalizationContext null validationContext null class "App\Entity\Book" ------------------------ -------------------

Slide 35

Slide 35 text

Browsing books

Slide 36

Slide 36 text

Browsing books We’ll use Index operation which allows to browse all items of your resource. ` `

Slide 37

Slide 37 text

Browsing books We’ll use Index operation which allows to browse all items of your resource. ` ` namespace App\Entity; use Sylius\Resource\Metadata\Index; use Sylius\Resource\Metadata\AsResource; use Sylius\Resource\Model\ResourceInterface; #[AsResource( operations: [ new Index(), ], )] // OR #[AsResource] #[Index] class Book implements ResourceInterface { }

Slide 38

Slide 38 text

Browsing books We’ll use Index operation which allows to browse all items of your resource. ` ` operations: [ new Index(), ], namespace App\Entity; use Sylius\Resource\Metadata\Index; use Sylius\Resource\Metadata\AsResource; use Sylius\Resource\Model\ResourceInterface; #[AsResource( )] // OR #[AsResource] #[Index] class Book implements ResourceInterface { }

Slide 39

Slide 39 text

Browsing books We’ll use Index operation which allows to browse all items of your resource. ` ` use Sylius\Resource\Metadata\Index; operations: [ new Index(), ], namespace App\Entity; use Sylius\Resource\Metadata\AsResource; use Sylius\Resource\Model\ResourceInterface; #[AsResource( )] // OR #[AsResource] #[Index] class Book implements ResourceInterface { }

Slide 40

Slide 40 text

Browsing books We’ll use Index operation which allows to browse all items of your resource. ` ` // OR #[AsResource] #[Index] namespace App\Entity; use Sylius\Resource\Metadata\Index; use Sylius\Resource\Metadata\AsResource; use Sylius\Resource\Model\ResourceInterface; #[AsResource( operations: [ new Index(), ], )] class Book implements ResourceInterface { }

Slide 41

Slide 41 text

Route

Slide 42

Slide 42 text

Route It will configure this route for your index operation. ` `

Slide 43

Slide 43 text

Route It will configure this route for your index operation. Name Method Path app_book_index GET /books ` `

Slide 44

Slide 44 text

Tips

Slide 45

Slide 45 text

Tips bin/console sylius:debug:resource app_book_index

Slide 46

Slide 46 text

Tips bin/console sylius:debug:resource app_book_index Operation Metadata ------------------ ------------------------ -------------------------------------------------------------------- Option Value ------------------------ -------------------------------------------------------------------- twigContextFactory "sylius.twig.context.factory.default" methods [ "GET" ] path null routeName "app_book_index" routePrefix null redirectToRoute null redirectArguments null provider "Sylius\Resource\Symfony\Request\State\Provider" processor "Sylius\Resource\Doctrine\Common\State\PersistProcessor" responder "Sylius\Resource\Symfony\Request\State\Responder" repository "app.repository.book" template "@SyliusAdminUi/crud/index.html.twig" #[...]

Slide 47

Slide 47 text

Create a grid You can use the Grid maker. $ bin/console make:grid

Slide 48

Slide 48 text

final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { public static function getName(): string { return 'app_book'; } public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder ->orderBy('name', 'asc') ->addField( StringField::create('name') ->setLabel('sylius.ui.name') ->setSortable(true) ) ->addField( StringField::create('author') ->setLabel('sylius.ui.author') ->setSortable(true) ) ; }

Slide 49

Slide 49 text

final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { public static function getName(): string { return 'app_book'; } public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder ->orderBy('name', 'asc') ->addField( StringField::create('name') ->setLabel('sylius.ui.name') ->setSortable(true) ) ->addField( StringField::create('author') ->setLabel('sylius.ui.author') ->setSortable(true) ) ; }

Slide 50

Slide 50 text

public static function getName(): string { return 'app_book'; } final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder ->orderBy('name', 'asc') ->addField( StringField::create('name') ->setLabel('sylius.ui.name') ->setSortable(true) ) ->addField( StringField::create('author') ->setLabel('sylius.ui.author') ->setSortable(true) ) ; }

Slide 51

Slide 51 text

->orderBy('name', 'asc') final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { public static function getName(): string { return 'app_book'; } public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder ->addField( StringField::create('name') ->setLabel('sylius.ui.name') ->setSortable(true) ) ->addField( StringField::create('author') ->setLabel('sylius.ui.author') ->setSortable(true) ) ; }

Slide 52

Slide 52 text

->addField( StringField::create('name') ->setLabel('sylius.ui.name') ->setSortable(true) ) final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { public static function getName(): string { return 'app_book'; } public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder ->orderBy('name', 'asc') ->addField( StringField::create('author') ->setLabel('sylius.ui.author') ->setSortable(true) ) ; }

Slide 53

Slide 53 text

->addField( StringField::create('author') ->setLabel('sylius.ui.author') ->setSortable(true) ) final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { public static function getName(): string { return 'app_book'; } public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder ->orderBy('name', 'asc') ->addField( StringField::create('name') ->setLabel('sylius.ui.name') ->setSortable(true) ) ; }

Slide 54

Slide 54 text

Use this grid for your index operation

Slide 55

Slide 55 text

Use this grid for your index operation To use a grid for you operation, you need to install the Sylius grid package

Slide 56

Slide 56 text

Use this grid for your index operation To use a grid for you operation, you need to install the Sylius grid package namespace App\Entity; use App\Grid\BookGrid; use Sylius\Resource\Metadata\Index; use Sylius\Resource\Metadata\AsResource; use Sylius\Resource\Model\ResourceInterface; #[AsResource] // You can use either the FQCN of your grid #[Index(grid: BookGrid::class)] // Or you can use the grid name #[Index(grid: 'app_book')] class Book implements ResourceInterface { }

Slide 57

Slide 57 text

Use this grid for your index operation To use a grid for you operation, you need to install the Sylius grid package // You can use either the FQCN of your grid #[Index(grid: BookGrid::class)] namespace App\Entity; use App\Grid\BookGrid; use Sylius\Resource\Metadata\Index; use Sylius\Resource\Metadata\AsResource; use Sylius\Resource\Model\ResourceInterface; #[AsResource] // Or you can use the grid name #[Index(grid: 'app_book')] class Book implements ResourceInterface { }

Slide 58

Slide 58 text

Use this grid for your index operation To use a grid for you operation, you need to install the Sylius grid package use App\Grid\BookGrid; // You can use either the FQCN of your grid #[Index(grid: BookGrid::class)] namespace App\Entity; use Sylius\Resource\Metadata\Index; use Sylius\Resource\Metadata\AsResource; use Sylius\Resource\Model\ResourceInterface; #[AsResource] // Or you can use the grid name #[Index(grid: 'app_book')] class Book implements ResourceInterface { }

Slide 59

Slide 59 text

Use this grid for your index operation To use a grid for you operation, you need to install the Sylius grid package // Or you can use the grid name #[Index(grid: 'app_book')] namespace App\Entity; use App\Grid\BookGrid; use Sylius\Resource\Metadata\Index; use Sylius\Resource\Metadata\AsResource; use Sylius\Resource\Model\ResourceInterface; #[AsResource] // You can use either the FQCN of your grid #[Index(grid: BookGrid::class)] class Book implements ResourceInterface { }

Slide 60

Slide 60 text

Use this grid for your index operation To use a grid for you operation, you need to install the Sylius grid package // Or you can use the grid name #[Index(grid: 'app_book')] namespace App\Entity; use App\Grid\BookGrid; use Sylius\Resource\Metadata\Index; use Sylius\Resource\Metadata\AsResource; use Sylius\Resource\Model\ResourceInterface; #[AsResource] // You can use either the FQCN of your grid #[Index(grid: BookGrid::class)] class Book implements ResourceInterface { }

Slide 61

Slide 61 text

bin/console sylius:debug:resource app_book_index Operation Metadata ------------------ ------------------------ -------------------------------------------------------------------- Option Value ------------------------ -------------------------------------------------------------------- #[...] provider "Sylius\Resource\Grid\State\RequestGridProvider" #[...]

Slide 62

Slide 62 text

No content

Slide 63

Slide 63 text

Adding/Editing books

Slide 64

Slide 64 text

Adding/Editing books We’ll use Create and Update operations which allows to add a new item of your resource. ` ` ` `

Slide 65

Slide 65 text

Adding/Editing books We’ll use Create and Update operations which allows to add a new item of your resource. ` ` ` ` namespace App\Entity; use App\Form\BookType; use Sylius\Resource\Metadata\Create; use Sylius\Resource\Metadata\Index; use Sylius\Resource\Metadata\Update; use Sylius\Resource\Metadata\AsResource; use Sylius\Resource\Model\ResourceInterface; #[AsResource( formType: BookType::class, operations: [ new Index(grid: BookGrid::class), new Create(), new Update(), ], )] class Book implements ResourceInterface { }

Slide 66

Slide 66 text

Adding/Editing books We’ll use Create and Update operations which allows to add a new item of your resource. ` ` ` ` formType: BookType::class, namespace App\Entity; use App\Form\BookType; use Sylius\Resource\Metadata\Create; use Sylius\Resource\Metadata\Index; use Sylius\Resource\Metadata\Update; use Sylius\Resource\Metadata\AsResource; use Sylius\Resource\Model\ResourceInterface; #[AsResource( operations: [ new Index(grid: BookGrid::class), new Create(), new Update(), ], )] class Book implements ResourceInterface { }

Slide 67

Slide 67 text

Adding/Editing books We’ll use Create and Update operations which allows to add a new item of your resource. ` ` ` ` use App\Form\BookType; formType: BookType::class, namespace App\Entity; use Sylius\Resource\Metadata\Create; use Sylius\Resource\Metadata\Index; use Sylius\Resource\Metadata\Update; use Sylius\Resource\Metadata\AsResource; use Sylius\Resource\Model\ResourceInterface; #[AsResource( operations: [ new Index(grid: BookGrid::class), new Create(), new Update(), ], )] class Book implements ResourceInterface { }

Slide 68

Slide 68 text

Adding/Editing books We’ll use Create and Update operations which allows to add a new item of your resource. ` ` ` ` new Create(), new Update(), namespace App\Entity; use App\Form\BookType; use Sylius\Resource\Metadata\Create; use Sylius\Resource\Metadata\Index; use Sylius\Resource\Metadata\Update; use Sylius\Resource\Metadata\AsResource; use Sylius\Resource\Model\ResourceInterface; #[AsResource( formType: BookType::class, operations: [ new Index(grid: BookGrid::class), ], )] class Book implements ResourceInterface { }

Slide 69

Slide 69 text

Adding/Editing books We’ll use Create and Update operations which allows to add a new item of your resource. ` ` ` ` use Sylius\Resource\Metadata\Create; use Sylius\Resource\Metadata\Update; new Create(), new Update(), namespace App\Entity; use App\Form\BookType; use Sylius\Resource\Metadata\Index; use Sylius\Resource\Metadata\AsResource; use Sylius\Resource\Model\ResourceInterface; #[AsResource( formType: BookType::class, operations: [ new Index(grid: BookGrid::class), ], )] class Book implements ResourceInterface { }

Slide 70

Slide 70 text

Route

Slide 71

Slide 71 text

Route It will configure this route for your create and your update operations. ` ` ` `

Slide 72

Slide 72 text

Route It will configure this route for your create and your update operations. Name Method Path app_book_create GET, POST /books/new app_book_update GET, PUT, PATCH, POST /books/{id}/edit ` ` ` `

Slide 73

Slide 73 text

final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder ->orderBy('name', 'asc') ->addField( // [...] ) ->addField( // [...] ) ->addActionGroup( MainActionGroup::create( CreateAction::create(), ) ) ->addActionGroup( ItemActionGroup::create( UpdateAction::create(), ) ) ; }

Slide 74

Slide 74 text

->addActionGroup( MainActionGroup::create( CreateAction::create(), ) ) final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder ->orderBy('name', 'asc') ->addField( // [...] ) ->addField( // [...] ) ->addActionGroup( ItemActionGroup::create( UpdateAction::create(), ) ) ; }

Slide 75

Slide 75 text

MainActionGroup::create( final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder ->orderBy('name', 'asc') ->addField( // [...] ) ->addField( // [...] ) ->addActionGroup( CreateAction::create(), ) ) ->addActionGroup( ItemActionGroup::create( UpdateAction::create(), ) ) ; }

Slide 76

Slide 76 text

CreateAction::create(), final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder ->orderBy('name', 'asc') ->addField( // [...] ) ->addField( // [...] ) ->addActionGroup( MainActionGroup::create( ) ) ->addActionGroup( ItemActionGroup::create( UpdateAction::create(), ) ) ; }

Slide 77

Slide 77 text

->addActionGroup( ItemActionGroup::create( UpdateAction::create(), ) ) final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder ->orderBy('name', 'asc') ->addField( // [...] ) ->addField( // [...] ) ->addActionGroup( MainActionGroup::create( CreateAction::create(), ) ) ; }

Slide 78

Slide 78 text

ItemActionGroup::create( final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder ->orderBy('name', 'asc') ->addField( // [...] ) ->addField( // [...] ) ->addActionGroup( MainActionGroup::create( CreateAction::create(), ) ) ->addActionGroup( UpdateAction::create(), ) ) ; }

Slide 79

Slide 79 text

UpdateAction::create(), final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder ->orderBy('name', 'asc') ->addField( // [...] ) ->addField( // [...] ) ->addActionGroup( MainActionGroup::create( CreateAction::create(), ) ) ->addActionGroup( ItemActionGroup::create( ) ) ; }

Slide 80

Slide 80 text

No content

Slide 81

Slide 81 text

No content

Slide 82

Slide 82 text

No content

Slide 83

Slide 83 text

No content

Slide 84

Slide 84 text

No content

Slide 85

Slide 85 text

No content

Slide 86

Slide 86 text

No content

Slide 87

Slide 87 text

Removing books

Slide 88

Slide 88 text

Removing books We’ll use Delete and Bulk delete operations which allows to remove existing items of your resource. ` ` ` `

Slide 89

Slide 89 text

Removing books We’ll use Delete and Bulk delete operations which allows to remove existing items of your resource. ` ` ` ` namespace App\Entity; use App\Form\BookType; use Sylius\Resource\Metadata\BulkDelete; use Sylius\Resource\Metadata\Create; use Sylius\Resource\Metadata\Delete; // [...] #[AsResource( formType: BookType::class, operations: [ new Index(grid: BookGrid::class), new Create(), new Update(), new Delete(), new BulkDelete(), ], )] class Book implements ResourceInterface { }

Slide 90

Slide 90 text

Removing books We’ll use Delete and Bulk delete operations which allows to remove existing items of your resource. ` ` ` ` new Delete(), new BulkDelete(), namespace App\Entity; use App\Form\BookType; use Sylius\Resource\Metadata\BulkDelete; use Sylius\Resource\Metadata\Create; use Sylius\Resource\Metadata\Delete; // [...] #[AsResource( formType: BookType::class, operations: [ new Index(grid: BookGrid::class), new Create(), new Update(), ], )] class Book implements ResourceInterface { }

Slide 91

Slide 91 text

Removing books We’ll use Delete and Bulk delete operations which allows to remove existing items of your resource. ` ` ` ` use Sylius\Resource\Metadata\BulkDelete; use Sylius\Resource\Metadata\Delete; new Delete(), new BulkDelete(), namespace App\Entity; use App\Form\BookType; use Sylius\Resource\Metadata\Create; // [...] #[AsResource( formType: BookType::class, operations: [ new Index(grid: BookGrid::class), new Create(), new Update(), ], )] class Book implements ResourceInterface { }

Slide 92

Slide 92 text

Route

Slide 93

Slide 93 text

Route It will configure this route for your delete and bulk_delete operations. ` ` ` `

Slide 94

Slide 94 text

Route It will configure this route for your delete and bulk_delete operations. Name Method Path app_book_delete DELETE, POST /books/{id}/delete app_book_bulk_delete DELETE, POST /books/bulk_delete ` ` ` `

Slide 95

Slide 95 text

final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addActionGroup( // [...] ) ->addActionGroup( ItemActionGroup::create( UpdateAction::create(), DeleteAction::create(), ) ) ->addActionGroup( BulkActionGroup::create( DeleteAction::create() ) ) ; } public function getResourceClass(): string

Slide 96

Slide 96 text

->addActionGroup( ItemActionGroup::create( UpdateAction::create(), DeleteAction::create(), ) ) final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addActionGroup( // [...] ) ->addActionGroup( BulkActionGroup::create( DeleteAction::create() ) ) ; } public function getResourceClass(): string

Slide 97

Slide 97 text

UpdateAction::create(), final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addActionGroup( // [...] ) ->addActionGroup( ItemActionGroup::create( DeleteAction::create(), ) ) ->addActionGroup( BulkActionGroup::create( DeleteAction::create() ) ) ; } public function getResourceClass(): string

Slide 98

Slide 98 text

DeleteAction::create(), final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addActionGroup( // [...] ) ->addActionGroup( ItemActionGroup::create( UpdateAction::create(), ) ) ->addActionGroup( BulkActionGroup::create( DeleteAction::create() ) ) ; } public function getResourceClass(): string

Slide 99

Slide 99 text

->addActionGroup( BulkActionGroup::create( DeleteAction::create() ) ) final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addActionGroup( // [...] ) ->addActionGroup( ItemActionGroup::create( UpdateAction::create(), DeleteAction::create(), ) ) ; } public function getResourceClass(): string

Slide 100

Slide 100 text

BulkActionGroup::create( final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addActionGroup( // [...] ) ->addActionGroup( ItemActionGroup::create( UpdateAction::create(), DeleteAction::create(), ) ) ->addActionGroup( DeleteAction::create() ) ) ; } public function getResourceClass(): string

Slide 101

Slide 101 text

DeleteAction::create() final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addActionGroup( // [...] ) ->addActionGroup( ItemActionGroup::create( UpdateAction::create(), DeleteAction::create(), ) ) ->addActionGroup( BulkActionGroup::create( ) ) ; } public function getResourceClass(): string

Slide 102

Slide 102 text

No content

Slide 103

Slide 103 text

No content

Slide 104

Slide 104 text

No content

Slide 105

Slide 105 text

No content

Slide 106

Slide 106 text

No content

Slide 107

Slide 107 text

No content

Slide 108

Slide 108 text

Publishing books

Slide 109

Slide 109 text

Publishing books We’ll use apply_state_machine_transition operation which allows to apply a transition using a state machine. ` `

Slide 110

Slide 110 text

Publishing books We’ll use apply_state_machine_transition operation which allows to apply a transition using a state machine. ` ` namespace App\Entity; use Sylius\Resource\Metadata\ApplyStateMachineTransition; use Sylius\Resource\Model\ResourceInterface; // [...] #[ApplyStateMachineTransition(stateMachineTransition: 'publish')] class Book implements ResourceInterface { }

Slide 111

Slide 111 text

Publishing books We’ll use apply_state_machine_transition operation which allows to apply a transition using a state machine. ` ` #[ApplyStateMachineTransition(stateMachineTransition: 'publish')] namespace App\Entity; use Sylius\Resource\Metadata\ApplyStateMachineTransition; use Sylius\Resource\Model\ResourceInterface; // [...] class Book implements ResourceInterface { }

Slide 112

Slide 112 text

Publishing books We’ll use apply_state_machine_transition operation which allows to apply a transition using a state machine. ` ` use Sylius\Resource\Metadata\ApplyStateMachineTransition; #[ApplyStateMachineTransition(stateMachineTransition: 'publish')] namespace App\Entity; use Sylius\Resource\Model\ResourceInterface; // [...] class Book implements ResourceInterface { }

Slide 113

Slide 113 text

Route

Slide 114

Slide 114 text

Route It will configure this route for your apply_state_machine_transition operation. ` `

Slide 115

Slide 115 text

Route It will configure this route for your apply_state_machine_transition operation. Name Method Path app_book_publish PUT, PATCH, POST /books/{id}/publish ` `

Slide 116

Slide 116 text

final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addField( StringField::create('author') ->setLabel('sylius.ui.author') ->setSortable(true) ) ->addField( TwigField::create('state', '@SyliusUi/Grid/Field/state.html.twig') ->setLabel('sylius.ui.state') ->setOption('vars', ['labels' => 'admin/book/label/state']), ) ; } public function getResourceClass(): string { return Book::class; } }

Slide 117

Slide 117 text

->addField( TwigField::create('state', '@SyliusUi/Grid/Field/state.html.twig') ->setLabel('sylius.ui.state') ->setOption('vars', ['labels' => 'admin/book/label/state']), ) ; final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addField( StringField::create('author') ->setLabel('sylius.ui.author') ->setSortable(true) ) } public function getResourceClass(): string { return Book::class; } }

Slide 118

Slide 118 text

TwigField::create('state', '@SyliusUi/Grid/Field/state.html.twig') final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addField( StringField::create('author') ->setLabel('sylius.ui.author') ->setSortable(true) ) ->addField( ->setLabel('sylius.ui.state') ->setOption('vars', ['labels' => 'admin/book/label/state']), ) ; } public function getResourceClass(): string { return Book::class; } }

Slide 119

Slide 119 text

->setLabel('sylius.ui.state') final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addField( StringField::create('author') ->setLabel('sylius.ui.author') ->setSortable(true) ) ->addField( TwigField::create('state', '@SyliusUi/Grid/Field/state.html.twig') ->setOption('vars', ['labels' => 'admin/book/label/state']), ) ; } public function getResourceClass(): string { return Book::class; } }

Slide 120

Slide 120 text

->setOption('vars', ['labels' => 'admin/book/label/state']), final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addField( StringField::create('author') ->setLabel('sylius.ui.author') ->setSortable(true) ) ->addField( TwigField::create('state', '@SyliusUi/Grid/Field/state.html.twig') ->setLabel('sylius.ui.state') ) ; } public function getResourceClass(): string { return Book::class; } }

Slide 121

Slide 121 text

{{ value|trans }}

Slide 122

Slide 122 text

No content

Slide 123

Slide 123 text

final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addActionGroup( ItemActionGroup::create( UpdateAction::create(), ApplyTransitionAction::create( name: 'publish', route: 'app_admin_book_publish', routeParameters: ['id' => 'resource.id'], options: [ 'class' => 'green', ], ) ->setLabel('app.ui.publish') ->setIcon('checkmark'), DeleteAction::create(), ) ) ; }

Slide 124

Slide 124 text

ApplyTransitionAction::create( name: 'publish', route: 'app_admin_book_publish', routeParameters: ['id' => 'resource.id'], options: [ 'class' => 'green', ], ) ->setLabel('app.ui.publish') ->setIcon('checkmark'), final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addActionGroup( ItemActionGroup::create( UpdateAction::create(), DeleteAction::create(), ) ) ; }

Slide 125

Slide 125 text

ApplyTransitionAction::create( final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addActionGroup( ItemActionGroup::create( UpdateAction::create(), name: 'publish', route: 'app_admin_book_publish', routeParameters: ['id' => 'resource.id'], options: [ 'class' => 'green', ], ) ->setLabel('app.ui.publish') ->setIcon('checkmark'), DeleteAction::create(), ) ) ; }

Slide 126

Slide 126 text

name: 'publish', final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addActionGroup( ItemActionGroup::create( UpdateAction::create(), ApplyTransitionAction::create( route: 'app_admin_book_publish', routeParameters: ['id' => 'resource.id'], options: [ 'class' => 'green', ], ) ->setLabel('app.ui.publish') ->setIcon('checkmark'), DeleteAction::create(), ) ) ; }

Slide 127

Slide 127 text

route: 'app_admin_book_publish', final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addActionGroup( ItemActionGroup::create( UpdateAction::create(), ApplyTransitionAction::create( name: 'publish', routeParameters: ['id' => 'resource.id'], options: [ 'class' => 'green', ], ) ->setLabel('app.ui.publish') ->setIcon('checkmark'), DeleteAction::create(), ) ) ; }

Slide 128

Slide 128 text

routeParameters: ['id' => 'resource.id'], final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addActionGroup( ItemActionGroup::create( UpdateAction::create(), ApplyTransitionAction::create( name: 'publish', route: 'app_admin_book_publish', options: [ 'class' => 'green', ], ) ->setLabel('app.ui.publish') ->setIcon('checkmark'), DeleteAction::create(), ) ) ; }

Slide 129

Slide 129 text

options: [ 'class' => 'green', ], final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addActionGroup( ItemActionGroup::create( UpdateAction::create(), ApplyTransitionAction::create( name: 'publish', route: 'app_admin_book_publish', routeParameters: ['id' => 'resource.id'], ) ->setLabel('app.ui.publish') ->setIcon('checkmark'), DeleteAction::create(), ) ) ; }

Slide 130

Slide 130 text

->setLabel('app.ui.publish') final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addActionGroup( ItemActionGroup::create( UpdateAction::create(), ApplyTransitionAction::create( name: 'publish', route: 'app_admin_book_publish', routeParameters: ['id' => 'resource.id'], options: [ 'class' => 'green', ], ) ->setIcon('checkmark'), DeleteAction::create(), ) ) ; }

Slide 131

Slide 131 text

->setIcon('checkmark'), final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addActionGroup( ItemActionGroup::create( UpdateAction::create(), ApplyTransitionAction::create( name: 'publish', route: 'app_admin_book_publish', routeParameters: ['id' => 'resource.id'], options: [ 'class' => 'green', ], ) ->setLabel('app.ui.publish') DeleteAction::create(), ) ) ; }

Slide 132

Slide 132 text

No content

Slide 133

Slide 133 text

No content

Slide 134

Slide 134 text

No content

Slide 135

Slide 135 text

Publishing books with custom processor

Slide 136

Slide 136 text

Publishing books with custom processor We configure an update operation. ` `

Slide 137

Slide 137 text

Publishing books with custom processor We configure an update operation. ` ` namespace App\Entity; use App\State\Processor\PublishBookProcessor; use Sylius\Resource\Metadata\Update; use Sylius\Resource\Model\ResourceInterface; // [...] #[Update( methods: ['PUT', 'PATCH', 'POST'], shortName: 'publish', processor: PublishBookProcessor::class, validate: false, )] class Book implements ResourceInterface { }

Slide 138

Slide 138 text

Publishing books with custom processor We configure an update operation. ` ` #[Update( methods: ['PUT', 'PATCH', 'POST'], shortName: 'publish', processor: PublishBookProcessor::class, validate: false, )] namespace App\Entity; use App\State\Processor\PublishBookProcessor; use Sylius\Resource\Metadata\Update; use Sylius\Resource\Model\ResourceInterface; // [...] class Book implements ResourceInterface { }

Slide 139

Slide 139 text

Publishing books with custom processor We configure an update operation. ` ` use Sylius\Resource\Metadata\Update; #[Update( methods: ['PUT', 'PATCH', 'POST'], shortName: 'publish', processor: PublishBookProcessor::class, validate: false, )] namespace App\Entity; use App\State\Processor\PublishBookProcessor; use Sylius\Resource\Model\ResourceInterface; // [...] class Book implements ResourceInterface { }

Slide 140

Slide 140 text

Publishing books with custom processor We configure an update operation. ` ` methods: ['PUT', 'PATCH', 'POST'], namespace App\Entity; use App\State\Processor\PublishBookProcessor; use Sylius\Resource\Metadata\Update; use Sylius\Resource\Model\ResourceInterface; // [...] #[Update( shortName: 'publish', processor: PublishBookProcessor::class, validate: false, )] class Book implements ResourceInterface { }

Slide 141

Slide 141 text

Publishing books with custom processor We configure an update operation. ` ` shortName: 'publish', namespace App\Entity; use App\State\Processor\PublishBookProcessor; use Sylius\Resource\Metadata\Update; use Sylius\Resource\Model\ResourceInterface; // [...] #[Update( methods: ['PUT', 'PATCH', 'POST'], processor: PublishBookProcessor::class, validate: false, )] class Book implements ResourceInterface { }

Slide 142

Slide 142 text

Publishing books with custom processor We configure an update operation. ` ` processor: PublishBookProcessor::class, namespace App\Entity; use App\State\Processor\PublishBookProcessor; use Sylius\Resource\Metadata\Update; use Sylius\Resource\Model\ResourceInterface; // [...] #[Update( methods: ['PUT', 'PATCH', 'POST'], shortName: 'publish', validate: false, )] class Book implements ResourceInterface { }

Slide 143

Slide 143 text

Publishing books with custom processor We configure an update operation. ` ` use App\State\Processor\PublishBookProcessor; processor: PublishBookProcessor::class, namespace App\Entity; use Sylius\Resource\Metadata\Update; use Sylius\Resource\Model\ResourceInterface; // [...] #[Update( methods: ['PUT', 'PATCH', 'POST'], shortName: 'publish', validate: false, )] class Book implements ResourceInterface { }

Slide 144

Slide 144 text

Publishing books with custom processor We configure an update operation. ` ` validate: false, namespace App\Entity; use App\State\Processor\PublishBookProcessor; use Sylius\Resource\Metadata\Update; use Sylius\Resource\Model\ResourceInterface; // [...] #[Update( methods: ['PUT', 'PATCH', 'POST'], shortName: 'publish', processor: PublishBookProcessor::class, )] class Book implements ResourceInterface { }

Slide 145

Slide 145 text

Route

Slide 146

Slide 146 text

Route It will configure this route for your publish operation. ` `

Slide 147

Slide 147 text

Route It will configure this route for your publish operation. Name Method Path app_book_publish PUT, PATCH, POST /books/{id}/publish ` `

Slide 148

Slide 148 text

// src/State/Processor/PublishBookProcessor.php use Sylius\Resource\Context\Context; use Sylius\Resource\Doctrine\Common\State\PersistProcessor; use Sylius\Resource\Metadata\Operation; use Sylius\Resource\State\ProcessorInterface; use Symfony\\Workflow\WorkflowInterface; final class PublishBookProcessor implements ProcessorInterface { public function __construct( private readonly WorkflowInterface $bookPublishingStateMachine, private readonly PersistProcessor $persistProcessor, ) { } public function process(mixed $data, Operation $operation, Context $context): mixed { if ($this->bookPublishingStateMachine->can($data, 'publish')) { $this->bookPublishingStateMachine->apply($data, 'publish'); } return $this->persistProcessor->process($data, $operation, $context); } }

Slide 149

Slide 149 text

final class PublishBookProcessor implements ProcessorInterface // src/State/Processor/PublishBookProcessor.php use Sylius\Resource\Context\Context; use Sylius\Resource\Doctrine\Common\State\PersistProcessor; use Sylius\Resource\Metadata\Operation; use Sylius\Resource\State\ProcessorInterface; use Symfony\\Workflow\WorkflowInterface; { public function __construct( private readonly WorkflowInterface $bookPublishingStateMachine, private readonly PersistProcessor $persistProcessor, ) { } public function process(mixed $data, Operation $operation, Context $context): mixed { if ($this->bookPublishingStateMachine->can($data, 'publish')) { $this->bookPublishingStateMachine->apply($data, 'publish'); } return $this->persistProcessor->process($data, $operation, $context); } }

Slide 150

Slide 150 text

use Sylius\Resource\State\ProcessorInterface; final class PublishBookProcessor implements ProcessorInterface // src/State/Processor/PublishBookProcessor.php use Sylius\Resource\Context\Context; use Sylius\Resource\Doctrine\Common\State\PersistProcessor; use Sylius\Resource\Metadata\Operation; use Symfony\\Workflow\WorkflowInterface; { public function __construct( private readonly WorkflowInterface $bookPublishingStateMachine, private readonly PersistProcessor $persistProcessor, ) { } public function process(mixed $data, Operation $operation, Context $context): mixed { if ($this->bookPublishingStateMachine->can($data, 'publish')) { $this->bookPublishingStateMachine->apply($data, 'publish'); } return $this->persistProcessor->process($data, $operation, $context); } }

Slide 151

Slide 151 text

private readonly WorkflowInterface $bookPublishingStateMachine, // src/State/Processor/PublishBookProcessor.php use Sylius\Resource\Context\Context; use Sylius\Resource\Doctrine\Common\State\PersistProcessor; use Sylius\Resource\Metadata\Operation; use Sylius\Resource\State\ProcessorInterface; use Symfony\\Workflow\WorkflowInterface; final class PublishBookProcessor implements ProcessorInterface { public function __construct( private readonly PersistProcessor $persistProcessor, ) { } public function process(mixed $data, Operation $operation, Context $context): mixed { if ($this->bookPublishingStateMachine->can($data, 'publish')) { $this->bookPublishingStateMachine->apply($data, 'publish'); } return $this->persistProcessor->process($data, $operation, $context); } }

Slide 152

Slide 152 text

use Symfony\\Workflow\WorkflowInterface; private readonly WorkflowInterface $bookPublishingStateMachine, // src/State/Processor/PublishBookProcessor.php use Sylius\Resource\Context\Context; use Sylius\Resource\Doctrine\Common\State\PersistProcessor; use Sylius\Resource\Metadata\Operation; use Sylius\Resource\State\ProcessorInterface; final class PublishBookProcessor implements ProcessorInterface { public function __construct( private readonly PersistProcessor $persistProcessor, ) { } public function process(mixed $data, Operation $operation, Context $context): mixed { if ($this->bookPublishingStateMachine->can($data, 'publish')) { $this->bookPublishingStateMachine->apply($data, 'publish'); } return $this->persistProcessor->process($data, $operation, $context); } }

Slide 153

Slide 153 text

private readonly PersistProcessor $persistProcessor, // src/State/Processor/PublishBookProcessor.php use Sylius\Resource\Context\Context; use Sylius\Resource\Doctrine\Common\State\PersistProcessor; use Sylius\Resource\Metadata\Operation; use Sylius\Resource\State\ProcessorInterface; use Symfony\\Workflow\WorkflowInterface; final class PublishBookProcessor implements ProcessorInterface { public function __construct( private readonly WorkflowInterface $bookPublishingStateMachine, ) { } public function process(mixed $data, Operation $operation, Context $context): mixed { if ($this->bookPublishingStateMachine->can($data, 'publish')) { $this->bookPublishingStateMachine->apply($data, 'publish'); } return $this->persistProcessor->process($data, $operation, $context); } }

Slide 154

Slide 154 text

use Sylius\Resource\Doctrine\Common\State\PersistProcessor; private readonly PersistProcessor $persistProcessor, // src/State/Processor/PublishBookProcessor.php use Sylius\Resource\Context\Context; use Sylius\Resource\Metadata\Operation; use Sylius\Resource\State\ProcessorInterface; use Symfony\\Workflow\WorkflowInterface; final class PublishBookProcessor implements ProcessorInterface { public function __construct( private readonly WorkflowInterface $bookPublishingStateMachine, ) { } public function process(mixed $data, Operation $operation, Context $context): mixed { if ($this->bookPublishingStateMachine->can($data, 'publish')) { $this->bookPublishingStateMachine->apply($data, 'publish'); } return $this->persistProcessor->process($data, $operation, $context); } }

Slide 155

Slide 155 text

public function process(mixed $data, Operation $operation, Context $context): mixed // src/State/Processor/PublishBookProcessor.php use Sylius\Resource\Context\Context; use Sylius\Resource\Doctrine\Common\State\PersistProcessor; use Sylius\Resource\Metadata\Operation; use Sylius\Resource\State\ProcessorInterface; use Symfony\\Workflow\WorkflowInterface; final class PublishBookProcessor implements ProcessorInterface { public function __construct( private readonly WorkflowInterface $bookPublishingStateMachine, private readonly PersistProcessor $persistProcessor, ) { } { if ($this->bookPublishingStateMachine->can($data, 'publish')) { $this->bookPublishingStateMachine->apply($data, 'publish'); } return $this->persistProcessor->process($data, $operation, $context); } }

Slide 156

Slide 156 text

if ($this->bookPublishingStateMachine->can($data, 'publish')) { // src/State/Processor/PublishBookProcessor.php use Sylius\Resource\Context\Context; use Sylius\Resource\Doctrine\Common\State\PersistProcessor; use Sylius\Resource\Metadata\Operation; use Sylius\Resource\State\ProcessorInterface; use Symfony\\Workflow\WorkflowInterface; final class PublishBookProcessor implements ProcessorInterface { public function __construct( private readonly WorkflowInterface $bookPublishingStateMachine, private readonly PersistProcessor $persistProcessor, ) { } public function process(mixed $data, Operation $operation, Context $context): mixed { $this->bookPublishingStateMachine->apply($data, 'publish'); } return $this->persistProcessor->process($data, $operation, $context); } }

Slide 157

Slide 157 text

$this->bookPublishingStateMachine->apply($data, 'publish'); // src/State/Processor/PublishBookProcessor.php use Sylius\Resource\Context\Context; use Sylius\Resource\Doctrine\Common\State\PersistProcessor; use Sylius\Resource\Metadata\Operation; use Sylius\Resource\State\ProcessorInterface; use Symfony\\Workflow\WorkflowInterface; final class PublishBookProcessor implements ProcessorInterface { public function __construct( private readonly WorkflowInterface $bookPublishingStateMachine, private readonly PersistProcessor $persistProcessor, ) { } public function process(mixed $data, Operation $operation, Context $context): mixed { if ($this->bookPublishingStateMachine->can($data, 'publish')) { } return $this->persistProcessor->process($data, $operation, $context); } }

Slide 158

Slide 158 text

return $this->persistProcessor->process($data, $operation, $context); // src/State/Processor/PublishBookProcessor.php use Sylius\Resource\Context\Context; use Sylius\Resource\Doctrine\Common\State\PersistProcessor; use Sylius\Resource\Metadata\Operation; use Sylius\Resource\State\ProcessorInterface; use Symfony\\Workflow\WorkflowInterface; final class PublishBookProcessor implements ProcessorInterface { public function __construct( private readonly WorkflowInterface $bookPublishingStateMachine, private readonly PersistProcessor $persistProcessor, ) { } public function process(mixed $data, Operation $operation, Context $context): mixed { if ($this->bookPublishingStateMachine->can($data, 'publish')) { $this->bookPublishingStateMachine->apply($data, 'publish'); } } }

Slide 159

Slide 159 text

No content

Slide 160

Slide 160 text

No content

Slide 161

Slide 161 text

No content

Slide 162

Slide 162 text

Publishing many books

Slide 163

Slide 163 text

Publishing many books We’ll use Bulk Update operation which allows to update several items of your resource at the same time. ` `

Slide 164

Slide 164 text

Publishing many books We’ll use Bulk Update operation which allows to update several items of your resource at the same time. ` ` namespace App\Entity; use App\State\Processor\PublishBookProcessor; use Sylius\Resource\Metadata\BulkUpdate; // [...] #[BulkUpdate( shortName: 'bulk_publish', processor: PublishBookProcessor::class, validate: false, )] class Book implements ResourceInterface { }

Slide 165

Slide 165 text

Publishing many books We’ll use Bulk Update operation which allows to update several items of your resource at the same time. ` ` #[BulkUpdate( namespace App\Entity; use App\State\Processor\PublishBookProcessor; use Sylius\Resource\Metadata\BulkUpdate; // [...] shortName: 'bulk_publish', processor: PublishBookProcessor::class, validate: false, )] class Book implements ResourceInterface { }

Slide 166

Slide 166 text

Publishing many books We’ll use Bulk Update operation which allows to update several items of your resource at the same time. ` ` use Sylius\Resource\Metadata\BulkUpdate; #[BulkUpdate( namespace App\Entity; use App\State\Processor\PublishBookProcessor; // [...] shortName: 'bulk_publish', processor: PublishBookProcessor::class, validate: false, )] class Book implements ResourceInterface { }

Slide 167

Slide 167 text

Publishing many books We’ll use Bulk Update operation which allows to update several items of your resource at the same time. ` ` shortName: 'bulk_publish', namespace App\Entity; use App\State\Processor\PublishBookProcessor; use Sylius\Resource\Metadata\BulkUpdate; // [...] #[BulkUpdate( processor: PublishBookProcessor::class, validate: false, )] class Book implements ResourceInterface { }

Slide 168

Slide 168 text

Publishing many books We’ll use Bulk Update operation which allows to update several items of your resource at the same time. ` ` processor: PublishBookProcessor::class, namespace App\Entity; use App\State\Processor\PublishBookProcessor; use Sylius\Resource\Metadata\BulkUpdate; // [...] #[BulkUpdate( shortName: 'bulk_publish', validate: false, )] class Book implements ResourceInterface { }

Slide 169

Slide 169 text

Publishing many books We’ll use Bulk Update operation which allows to update several items of your resource at the same time. ` ` validate: false, namespace App\Entity; use App\State\Processor\PublishBookProcessor; use Sylius\Resource\Metadata\BulkUpdate; // [...] #[BulkUpdate( shortName: 'bulk_publish', processor: PublishBookProcessor::class, )] class Book implements ResourceInterface { }

Slide 170

Slide 170 text

Route

Slide 171

Slide 171 text

Route It will configure this route for your bulk_publish operation. ` `

Slide 172

Slide 172 text

Route It will configure this route for your bulk_publish operation. Name Method Path app_book_bulk_publish PUT, PATCH, POST /books/bulk_publish ` `

Slide 173

Slide 173 text

final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addActionGroup( BulkActionGroup::create( DeleteAction::create(), Action::create('publish', 'apply_transition') ->setLabel('app.ui.publish') ->setIcon('icon: checkmark') ->setOptions([ 'link' => [ 'route' => 'app_admin_book_bulk_publish', ], 'class' => 'green', ]), ) ) ; } public function getResourceClass(): string

Slide 174

Slide 174 text

Action::create('publish', 'apply_transition') ->setLabel('app.ui.publish') ->setIcon('icon: checkmark') ->setOptions([ 'link' => [ 'route' => 'app_admin_book_bulk_publish', ], 'class' => 'green', ]), ) ) ; } final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addActionGroup( BulkActionGroup::create( DeleteAction::create(), public function getResourceClass(): string

Slide 175

Slide 175 text

Action::create('publish', 'apply_transition') final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addActionGroup( BulkActionGroup::create( DeleteAction::create(), ->setLabel('app.ui.publish') ->setIcon('icon: checkmark') ->setOptions([ 'link' => [ 'route' => 'app_admin_book_bulk_publish', ], 'class' => 'green', ]), ) ) ; } public function getResourceClass(): string

Slide 176

Slide 176 text

->setOptions([ 'link' => [ 'route' => 'app_admin_book_bulk_publish', ], 'class' => 'green', ]), ) final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addActionGroup( BulkActionGroup::create( DeleteAction::create(), Action::create('publish', 'apply_transition') ->setLabel('app.ui.publish') ->setIcon('icon: checkmark') ) ; } public function getResourceClass(): string

Slide 177

Slide 177 text

'link' => [ 'route' => 'app_admin_book_bulk_publish', ], final class BookGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder // [...] ->addActionGroup( BulkActionGroup::create( DeleteAction::create(), Action::create('publish', 'apply_transition') ->setLabel('app.ui.publish') ->setIcon('icon: checkmark') ->setOptions([ 'class' => 'green', ]), ) ) ; } public function getResourceClass(): string

Slide 178

Slide 178 text

No content

Slide 179

Slide 179 text

No content

Slide 180

Slide 180 text

No content

Slide 181

Slide 181 text

No content

Slide 182

Slide 182 text

Sylius Resource without driver

Slide 183

Slide 183 text

Sylius Resource without driver No Doctrine driver

Slide 184

Slide 184 text

Sylius Resource without driver No Doctrine driver Retrieve data with providers

Slide 185

Slide 185 text

Sylius Resource without driver No Doctrine driver Retrieve data with providers Persist data with processors

Slide 186

Slide 186 text

Resource with data from a CSV file config/data/board_games.csv 6b2fff2b-0b43-489b-8c48-9c0427a1c4c7,Stone Age,"Travel to the time of hunters and gatherers in this classic game of tool d068029a-0c32-4728-95bf-5f614d53440b,Ticket to Ride,"Build your railroad across North America to connect cities and comp 5ba27cbd-e230-48b7-86ae-ad2eaa05ebc0,7 Wonders,"Draft cards to develop your ancient civilization and build its Wonder of 2919785a-66e7-44da-b356-b98e07fbb9e8,Puerto Rico,"Ship goods, construct buildings, and choose roles that benefit you mor c4856c93-3a41-40eb-9994-f58a1035d99b,Azul, "Artfully embellish the walls of your palace by drafting the most beautiful t a953d760-07d5-4add-b87e-b483ebb194df,Die Fürsten von Florenz,"Attract artisans and scholars to your palazzo by building ce461300-25c3-4a72-aa7d-6ec7021d7b80,The Voyages of Marco Polo,"Using unique abilities, fulfill contracts and reach your 599dcd98-8167-4f4a-b181-efd7c24bb434,Tigris & Euphrates,"Keep your Mesopotamian civilisation in perfect balance through 305749e6-7a05-468a-b1aa-46ee6c1a89ac,Patchwork,"Piece together a quilt and leave no holes to become the button master." 5e980dad-d8ef-4e47-910a-4dc9f91b38fd,Cartagena,"Groups of pirates race to reach their ship and escape from Cartegena." 6a47110b-b65d-4e94-9ce0-a06cd7823ecc,Village,"Send your villagers to work, travel, pray, and... die when it brings the m e75c5edd-bf6a-49f8-a409-90183aea660c,Splendor,"Renaissance merchants race to grab gems, acquire property, and please nob 74c0d7ba-8acf-46eb-a6a7-c8f04c1860ff,Ra,"Bid to acquire the most valuable sets of Egyptian artifacts and resources." 44bc972e-6a0e-423a-9140-caae3f7f8710,Carcassonne,"Shape the medieval landscape of France, claiming cities, monasteries a 0a937d58-24dd-4dae-894a-b600dfa334d4,Modern Art,"Four types of auctions challenge players in this classic game of art sp c3661009-d024-4c83-8ef6-a967a0a21e6f,Goa,"Run a spice trade business in colonial-era India in this closed-loop economy g edbb5801-f1ae-4c14-b86a-130a7c3a1c4a,Shogun,"Gain control of medieval Japan by amassing troops and sending them out to b 1dec8957-3203-4f84-95c5-ceb3754e4b50,Samurai,"Dispute the favor of three different castes in order to unite Japan under 110c7432-c754-4174-9d0b-7402dc57a500,Kingdomino,"Build a kingdom with varied terrains on domino-shaped tiles in this fas

Slide 187

Slide 187 text

namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; use Sylius\Resource\Metadata\AsResource; use Sylius\Resource\Model\ResourceInterface; use Symfony\\Validator\Constraints\NotBlank; #[AsResource(driver: false)] final class BoardGameResource implements ResourceInterface { public function __construct( public ?string $id = null, #[NotBlank] public ?string $name = null, public ?string $shortDescription = null, ) { } public function getId(): string { return $this->id; } }

Slide 188

Slide 188 text

#[AsResource(driver: false)] namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; use Sylius\Resource\Metadata\AsResource; use Sylius\Resource\Model\ResourceInterface; use Symfony\\Validator\Constraints\NotBlank; final class BoardGameResource implements ResourceInterface { public function __construct( public ?string $id = null, #[NotBlank] public ?string $name = null, public ?string $shortDescription = null, ) { } public function getId(): string { return $this->id; } }

Slide 189

Slide 189 text

use Sylius\Resource\Metadata\AsResource; #[AsResource(driver: false)] namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; use Sylius\Resource\Model\ResourceInterface; use Symfony\\Validator\Constraints\NotBlank; final class BoardGameResource implements ResourceInterface { public function __construct( public ?string $id = null, #[NotBlank] public ?string $name = null, public ?string $shortDescription = null, ) { } public function getId(): string { return $this->id; } }

Slide 190

Slide 190 text

final class BoardGameResource implements ResourceInterface namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; use Sylius\Resource\Metadata\AsResource; use Sylius\Resource\Model\ResourceInterface; use Symfony\\Validator\Constraints\NotBlank; #[AsResource(driver: false)] { public function __construct( public ?string $id = null, #[NotBlank] public ?string $name = null, public ?string $shortDescription = null, ) { } public function getId(): string { return $this->id; } }

Slide 191

Slide 191 text

use Sylius\Resource\Model\ResourceInterface; final class BoardGameResource implements ResourceInterface namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; use Sylius\Resource\Metadata\AsResource; use Symfony\\Validator\Constraints\NotBlank; #[AsResource(driver: false)] { public function __construct( public ?string $id = null, #[NotBlank] public ?string $name = null, public ?string $shortDescription = null, ) { } public function getId(): string { return $this->id; } }

Slide 192

Slide 192 text

use Sylius\Resource\Model\ResourceInterface; final class BoardGameResource implements ResourceInterface public function getId(): string { return $this->id; } namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; use Sylius\Resource\Metadata\AsResource; use Symfony\\Validator\Constraints\NotBlank; #[AsResource(driver: false)] { public function __construct( public ?string $id = null, #[NotBlank] public ?string $name = null, public ?string $shortDescription = null, ) { } }

Slide 193

Slide 193 text

Browsing board games

Slide 194

Slide 194 text

Browsing board games namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; use Sylius\Resource\Metadata\Index; use Sylius\Resource\Metadata\AsResource; use Sylius\Resource\Model\ResourceInterface; use Symfony\\Validator\Constraints\NotBlank; #[AsResource(driver: false)] #[Index( grid: 'app_board_game' )] final class BoardGameResource implements ResourceInterface { // [...] }

Slide 195

Slide 195 text

Browsing board games #[Index( grid: 'app_board_game' )] final class BoardGameResource implements ResourceInterface { namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; use Sylius\Resource\Metadata\Index; use Sylius\Resource\Metadata\AsResource; use Sylius\Resource\Model\ResourceInterface; use Symfony\\Validator\Constraints\NotBlank; #[AsResource(driver: false)] // [...] }

Slide 196

Slide 196 text

Browsing board games use Sylius\Resource\Metadata\Index; #[Index( grid: 'app_board_game' )] final class BoardGameResource implements ResourceInterface { namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; use Sylius\Resource\Metadata\AsResource; use Sylius\Resource\Model\ResourceInterface; use Symfony\\Validator\Constraints\NotBlank; #[AsResource(driver: false)] // [...] }

Slide 197

Slide 197 text

// src/BoardGameBlog/Infrastructure/Sylius/Grid/BoardGameGrid.php final class BoardGameGrid extends AbstractGrid implements ResourceAwareGridInterface { public static function getName(): string { return 'app_board_game'; } public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder ->setProvider(BoardGameGridProvider::class) ->addField( StringField::create('name') ->setLabel('Name') ) ->addField( StringField::create('shortDescription') ->setLabel('Short Description'), ) ; } public function getResourceClass(): string { return BoardGameResource::class; } }

Slide 198

Slide 198 text

public function getResourceClass(): string { return BoardGameResource::class; } // src/BoardGameBlog/Infrastructure/Sylius/Grid/BoardGameGrid.php final class BoardGameGrid extends AbstractGrid implements ResourceAwareGridInterface { public static function getName(): string { return 'app_board_game'; } public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder ->setProvider(BoardGameGridProvider::class) ->addField( StringField::create('name') ->setLabel('Name') ) ->addField( StringField::create('shortDescription') ->setLabel('Short Description'), ) ; } }

Slide 199

Slide 199 text

->setProvider(BoardGameGridProvider::class) // src/BoardGameBlog/Infrastructure/Sylius/Grid/BoardGameGrid.php final class BoardGameGrid extends AbstractGrid implements ResourceAwareGridInterface { public static function getName(): string { return 'app_board_game'; } public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder ->addField( StringField::create('name') ->setLabel('Name') ) ->addField( StringField::create('shortDescription') ->setLabel('Short Description'), ) ; } public function getResourceClass(): string { return BoardGameResource::class; } }

Slide 200

Slide 200 text

namespace App\BoardGameBlog\Infrastructure\Sylius\Grid\DataProvider; // [...] use Sylius\Grid\Data\DataProviderInterface; final class BoardGameGridProvider implements DataProviderInterface { public function __construct(private readonly string $dataDir) {} public function getData(Grid $grid, Parameters $parameters): Pagerfanta { $data = []; foreach ($this->getFileData() as $row) { [$id, $name, $shortDescription] = $row; $data[] = new BoardGameResource( id: $id, name: $name, shortDescription: $shortDescription, ); } return new Pagerfanta(new ArrayAdapter($data)); }

Slide 201

Slide 201 text

namespace App\BoardGameBlog\Infrastructure\Sylius\Grid\DataProvider; // [...] use Sylius\Grid\Data\DataProviderInterface; final class BoardGameGridProvider implements DataProviderInterface { public function __construct(private readonly string $dataDir) {} public function getData(Grid $grid, Parameters $parameters): Pagerfanta { $data = []; foreach ($this->getFileData() as $row) { [$id, $name, $shortDescription] = $row; $data[] = new BoardGameResource( id: $id, name: $name, shortDescription: $shortDescription, ); } return new Pagerfanta(new ArrayAdapter($data)); }

Slide 202

Slide 202 text

use Sylius\Grid\Data\DataProviderInterface; final class BoardGameGridProvider implements DataProviderInterface namespace App\BoardGameBlog\Infrastructure\Sylius\Grid\DataProvider; // [...] { public function __construct(private readonly string $dataDir) {} public function getData(Grid $grid, Parameters $parameters): Pagerfanta { $data = []; foreach ($this->getFileData() as $row) { [$id, $name, $shortDescription] = $row; $data[] = new BoardGameResource( id: $id, name: $name, shortDescription: $shortDescription, ); } return new Pagerfanta(new ArrayAdapter($data)); }

Slide 203

Slide 203 text

use Sylius\Grid\Data\DataProviderInterface; final class BoardGameGridProvider implements DataProviderInterface public function getData(Grid $grid, Parameters $parameters): Pagerfanta namespace App\BoardGameBlog\Infrastructure\Sylius\Grid\DataProvider; // [...] { public function __construct(private readonly string $dataDir) {} { $data = []; foreach ($this->getFileData() as $row) { [$id, $name, $shortDescription] = $row; $data[] = new BoardGameResource( id: $id, name: $name, shortDescription: $shortDescription, ); } return new Pagerfanta(new ArrayAdapter($data)); }

Slide 204

Slide 204 text

$data = []; namespace App\BoardGameBlog\Infrastructure\Sylius\Grid\DataProvider; // [...] use Sylius\Grid\Data\DataProviderInterface; final class BoardGameGridProvider implements DataProviderInterface { public function __construct(private readonly string $dataDir) {} public function getData(Grid $grid, Parameters $parameters): Pagerfanta { foreach ($this->getFileData() as $row) { [$id, $name, $shortDescription] = $row; $data[] = new BoardGameResource( id: $id, name: $name, shortDescription: $shortDescription, ); } return new Pagerfanta(new ArrayAdapter($data)); }

Slide 205

Slide 205 text

foreach ($this->getFileData() as $row) { namespace App\BoardGameBlog\Infrastructure\Sylius\Grid\DataProvider; // [...] use Sylius\Grid\Data\DataProviderInterface; final class BoardGameGridProvider implements DataProviderInterface { public function __construct(private readonly string $dataDir) {} public function getData(Grid $grid, Parameters $parameters): Pagerfanta { $data = []; [$id, $name, $shortDescription] = $row; $data[] = new BoardGameResource( id: $id, name: $name, shortDescription: $shortDescription, ); } return new Pagerfanta(new ArrayAdapter($data)); }

Slide 206

Slide 206 text

[$id, $name, $shortDescription] = $row; namespace App\BoardGameBlog\Infrastructure\Sylius\Grid\DataProvider; // [...] use Sylius\Grid\Data\DataProviderInterface; final class BoardGameGridProvider implements DataProviderInterface { public function __construct(private readonly string $dataDir) {} public function getData(Grid $grid, Parameters $parameters): Pagerfanta { $data = []; foreach ($this->getFileData() as $row) { $data[] = new BoardGameResource( id: $id, name: $name, shortDescription: $shortDescription, ); } return new Pagerfanta(new ArrayAdapter($data)); }

Slide 207

Slide 207 text

$data[] = new BoardGameResource( id: $id, name: $name, shortDescription: $shortDescription, ); namespace App\BoardGameBlog\Infrastructure\Sylius\Grid\DataProvider; // [...] use Sylius\Grid\Data\DataProviderInterface; final class BoardGameGridProvider implements DataProviderInterface { public function __construct(private readonly string $dataDir) {} public function getData(Grid $grid, Parameters $parameters): Pagerfanta { $data = []; foreach ($this->getFileData() as $row) { [$id, $name, $shortDescription] = $row; } return new Pagerfanta(new ArrayAdapter($data)); }

Slide 208

Slide 208 text

return new Pagerfanta(new ArrayAdapter($data)); namespace App\BoardGameBlog\Infrastructure\Sylius\Grid\DataProvider; // [...] use Sylius\Grid\Data\DataProviderInterface; final class BoardGameGridProvider implements DataProviderInterface { public function __construct(private readonly string $dataDir) {} public function getData(Grid $grid, Parameters $parameters): Pagerfanta { $data = []; foreach ($this->getFileData() as $row) { [$id, $name, $shortDescription] = $row; $data[] = new BoardGameResource( id: $id, name: $name, shortDescription: $shortDescription, ); } }

Slide 209

Slide 209 text

namespace App\BoardGameBlog\Infrastructure\Sylius\Grid\DataProvider; // [...] use Sylius\Grid\Data\DataProviderInterface; final class BoardGameGridProvider implements DataProviderInterface { // [...] private function getFileData(): array { return array_map('str_getcsv', file($this->dataDir . '/board_games.csv')); } }

Slide 210

Slide 210 text

private function getFileData(): array { return array_map('str_getcsv', file($this->dataDir . '/board_games.csv')); } namespace App\BoardGameBlog\Infrastructure\Sylius\Grid\DataProvider; // [...] use Sylius\Grid\Data\DataProviderInterface; final class BoardGameGridProvider implements DataProviderInterface { // [...] }

Slide 211

Slide 211 text

No content

Slide 212

Slide 212 text

No content

Slide 213

Slide 213 text

Adding board games

Slide 214

Slide 214 text

Adding board games namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; // [...] use App\BoardGameBlog\Infrastructure\Sylius\State\Processor\CreateBoardGameProcessor; use App\BoardGameBlog\Infrastructure\Symfony\Form\Type\BoardGameType; use Sylius\Resource\Metadata\Index; use Sylius\Resource\Metadata\Create; #[AsResource( driver: false, formType: BoardGameType::class), ] #[Index( grid: 'app_board_game' )] #[Create( processor: CreateBoardGameProcessor::class, )] final class BoardGameResource implements ResourceInterface { // [...] }

Slide 215

Slide 215 text

Adding board games formType: BoardGameType::class), namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; // [...] use App\BoardGameBlog\Infrastructure\Sylius\State\Processor\CreateBoardGameProcessor; use App\BoardGameBlog\Infrastructure\Symfony\Form\Type\BoardGameType; use Sylius\Resource\Metadata\Index; use Sylius\Resource\Metadata\Create; #[AsResource( driver: false, ] #[Index( grid: 'app_board_game' )] #[Create( processor: CreateBoardGameProcessor::class, )] final class BoardGameResource implements ResourceInterface { // [...] }

Slide 216

Slide 216 text

Adding board games use App\BoardGameBlog\Infrastructure\Symfony\Form\Type\BoardGameType; formType: BoardGameType::class), namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; // [...] use App\BoardGameBlog\Infrastructure\Sylius\State\Processor\CreateBoardGameProcessor; use Sylius\Resource\Metadata\Index; use Sylius\Resource\Metadata\Create; #[AsResource( driver: false, ] #[Index( grid: 'app_board_game' )] #[Create( processor: CreateBoardGameProcessor::class, )] final class BoardGameResource implements ResourceInterface { // [...] }

Slide 217

Slide 217 text

Adding board games processor: CreateBoardGameProcessor::class, namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; // [...] use App\BoardGameBlog\Infrastructure\Sylius\State\Processor\CreateBoardGameProcessor; use App\BoardGameBlog\Infrastructure\Symfony\Form\Type\BoardGameType; use Sylius\Resource\Metadata\Index; use Sylius\Resource\Metadata\Create; #[AsResource( driver: false, formType: BoardGameType::class), ] #[Index( grid: 'app_board_game' )] #[Create( )] final class BoardGameResource implements ResourceInterface { // [...] }

Slide 218

Slide 218 text

Adding board games use App\BoardGameBlog\Infrastructure\Sylius\State\Processor\CreateBoardGameProcessor; processor: CreateBoardGameProcessor::class, namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; // [...] use App\BoardGameBlog\Infrastructure\Symfony\Form\Type\BoardGameType; use Sylius\Resource\Metadata\Index; use Sylius\Resource\Metadata\Create; #[AsResource( driver: false, formType: BoardGameType::class), ] #[Index( grid: 'app_board_game' )] #[Create( )] final class BoardGameResource implements ResourceInterface { // [...] }

Slide 219

Slide 219 text

namespace App\BoardGameBlog\Infrastructure\Sylius\State\Processor; // [...] use Sylius\Resource\State\ProcessorInterface; final class CreateBoardGameProcessor implements ProcessorInterface { public function __construct(private readonly string $dataDir) {} public function process(mixed $data, Operation $operation, Context $context): mixed { Assert::isInstanceOf($data, BoardGameResource::class); $this->createBoardGame($data); return null; } private function createBoardGame(BoardGameResource $boardGameResource): void { $handle = fopen($this->dataDir . '/board_games.csv', 'a'); fputcsv($handle, [(string) Uuid::v4(), $boardGameResource->name, $boardGameResource->shortDescription]); fclose($handle); } }

Slide 220

Slide 220 text

final class CreateBoardGameProcessor implements ProcessorInterface namespace App\BoardGameBlog\Infrastructure\Sylius\State\Processor; // [...] use Sylius\Resource\State\ProcessorInterface; { public function __construct(private readonly string $dataDir) {} public function process(mixed $data, Operation $operation, Context $context): mixed { Assert::isInstanceOf($data, BoardGameResource::class); $this->createBoardGame($data); return null; } private function createBoardGame(BoardGameResource $boardGameResource): void { $handle = fopen($this->dataDir . '/board_games.csv', 'a'); fputcsv($handle, [(string) Uuid::v4(), $boardGameResource->name, $boardGameResource->shortDescription]); fclose($handle); } }

Slide 221

Slide 221 text

use Sylius\Resource\State\ProcessorInterface; final class CreateBoardGameProcessor implements ProcessorInterface namespace App\BoardGameBlog\Infrastructure\Sylius\State\Processor; // [...] { public function __construct(private readonly string $dataDir) {} public function process(mixed $data, Operation $operation, Context $context): mixed { Assert::isInstanceOf($data, BoardGameResource::class); $this->createBoardGame($data); return null; } private function createBoardGame(BoardGameResource $boardGameResource): void { $handle = fopen($this->dataDir . '/board_games.csv', 'a'); fputcsv($handle, [(string) Uuid::v4(), $boardGameResource->name, $boardGameResource->shortDescription]); fclose($handle); } }

Slide 222

Slide 222 text

use Sylius\Resource\State\ProcessorInterface; final class CreateBoardGameProcessor implements ProcessorInterface public function process(mixed $data, Operation $operation, Context $context): mixed namespace App\BoardGameBlog\Infrastructure\Sylius\State\Processor; // [...] { public function __construct(private readonly string $dataDir) {} { Assert::isInstanceOf($data, BoardGameResource::class); $this->createBoardGame($data); return null; } private function createBoardGame(BoardGameResource $boardGameResource): void { $handle = fopen($this->dataDir . '/board_games.csv', 'a'); fputcsv($handle, [(string) Uuid::v4(), $boardGameResource->name, $boardGameResource->shortDescription]); fclose($handle); } }

Slide 223

Slide 223 text

Assert::isInstanceOf($data, BoardGameResource::class); namespace App\BoardGameBlog\Infrastructure\Sylius\State\Processor; // [...] use Sylius\Resource\State\ProcessorInterface; final class CreateBoardGameProcessor implements ProcessorInterface { public function __construct(private readonly string $dataDir) {} public function process(mixed $data, Operation $operation, Context $context): mixed { $this->createBoardGame($data); return null; } private function createBoardGame(BoardGameResource $boardGameResource): void { $handle = fopen($this->dataDir . '/board_games.csv', 'a'); fputcsv($handle, [(string) Uuid::v4(), $boardGameResource->name, $boardGameResource->shortDescription]); fclose($handle); } }

Slide 224

Slide 224 text

$this->createBoardGame($data); namespace App\BoardGameBlog\Infrastructure\Sylius\State\Processor; // [...] use Sylius\Resource\State\ProcessorInterface; final class CreateBoardGameProcessor implements ProcessorInterface { public function __construct(private readonly string $dataDir) {} public function process(mixed $data, Operation $operation, Context $context): mixed { Assert::isInstanceOf($data, BoardGameResource::class); return null; } private function createBoardGame(BoardGameResource $boardGameResource): void { $handle = fopen($this->dataDir . '/board_games.csv', 'a'); fputcsv($handle, [(string) Uuid::v4(), $boardGameResource->name, $boardGameResource->shortDescription]); fclose($handle); } }

Slide 225

Slide 225 text

$this->createBoardGame($data); private function createBoardGame(BoardGameResource $boardGameResource): void { $handle = fopen($this->dataDir . '/board_games.csv', 'a'); fputcsv($handle, [(string) Uuid::v4(), $boardGameResource->name, $boardGameResource->shortDescription]); fclose($handle); } namespace App\BoardGameBlog\Infrastructure\Sylius\State\Processor; // [...] use Sylius\Resource\State\ProcessorInterface; final class CreateBoardGameProcessor implements ProcessorInterface { public function __construct(private readonly string $dataDir) {} public function process(mixed $data, Operation $operation, Context $context): mixed { Assert::isInstanceOf($data, BoardGameResource::class); return null; } }

Slide 226

Slide 226 text

$handle = fopen($this->dataDir . '/board_games.csv', 'a'); namespace App\BoardGameBlog\Infrastructure\Sylius\State\Processor; // [...] use Sylius\Resource\State\ProcessorInterface; final class CreateBoardGameProcessor implements ProcessorInterface { public function __construct(private readonly string $dataDir) {} public function process(mixed $data, Operation $operation, Context $context): mixed { Assert::isInstanceOf($data, BoardGameResource::class); $this->createBoardGame($data); return null; } private function createBoardGame(BoardGameResource $boardGameResource): void { fputcsv($handle, [(string) Uuid::v4(), $boardGameResource->name, $boardGameResource->shortDescription]); fclose($handle); } }

Slide 227

Slide 227 text

fputcsv($handle, [(string) Uuid::v4(), $boardGameResource->name, $boardGameResource->shortDescription]); namespace App\BoardGameBlog\Infrastructure\Sylius\State\Processor; // [...] use Sylius\Resource\State\ProcessorInterface; final class CreateBoardGameProcessor implements ProcessorInterface { public function __construct(private readonly string $dataDir) {} public function process(mixed $data, Operation $operation, Context $context): mixed { Assert::isInstanceOf($data, BoardGameResource::class); $this->createBoardGame($data); return null; } private function createBoardGame(BoardGameResource $boardGameResource): void { $handle = fopen($this->dataDir . '/board_games.csv', 'a'); fclose($handle); } }

Slide 228

Slide 228 text

fclose($handle); namespace App\BoardGameBlog\Infrastructure\Sylius\State\Processor; // [...] use Sylius\Resource\State\ProcessorInterface; final class CreateBoardGameProcessor implements ProcessorInterface { public function __construct(private readonly string $dataDir) {} public function process(mixed $data, Operation $operation, Context $context): mixed { Assert::isInstanceOf($data, BoardGameResource::class); $this->createBoardGame($data); return null; } private function createBoardGame(BoardGameResource $boardGameResource): void { $handle = fopen($this->dataDir . '/board_games.csv', 'a'); fputcsv($handle, [(string) Uuid::v4(), $boardGameResource->name, $boardGameResource->shortDescription]); } }

Slide 229

Slide 229 text

return null; namespace App\BoardGameBlog\Infrastructure\Sylius\State\Processor; // [...] use Sylius\Resource\State\ProcessorInterface; final class CreateBoardGameProcessor implements ProcessorInterface { public function __construct(private readonly string $dataDir) {} public function process(mixed $data, Operation $operation, Context $context): mixed { Assert::isInstanceOf($data, BoardGameResource::class); $this->createBoardGame($data); } private function createBoardGame(BoardGameResource $boardGameResource): void { $handle = fopen($this->dataDir . '/board_games.csv', 'a'); fputcsv($handle, [(string) Uuid::v4(), $boardGameResource->name, $boardGameResource->shortDescription]); fclose($handle); } }

Slide 230

Slide 230 text

No content

Slide 231

Slide 231 text

No content

Slide 232

Slide 232 text

No content

Slide 233

Slide 233 text

No content

Slide 234

Slide 234 text

No content

Slide 235

Slide 235 text

No content

Slide 236

Slide 236 text

Editing board games

Slide 237

Slide 237 text

Editing board games namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; // [...] use App\BoardGameBlog\Infrastructure\Sylius\State\Processor\UpdateBoardGameProcessor; use App\BoardGameBlog\Infrastructure\Sylius\State\Provider\BoardGameItemProvider; use Sylius\Resource\Metadata\Update; // [...] #[Update( provider: BoardGameItemProvider::class, processor: UpdateBoardGameProcessor::class, )] final class BoardGameResource implements ResourceInterface { // [...] }

Slide 238

Slide 238 text

Editing board games #[Update( namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; // [...] use App\BoardGameBlog\Infrastructure\Sylius\State\Processor\UpdateBoardGameProcessor; use App\BoardGameBlog\Infrastructure\Sylius\State\Provider\BoardGameItemProvider; use Sylius\Resource\Metadata\Update; // [...] provider: BoardGameItemProvider::class, processor: UpdateBoardGameProcessor::class, )] final class BoardGameResource implements ResourceInterface { // [...] }

Slide 239

Slide 239 text

Editing board games use Sylius\Resource\Metadata\Update; #[Update( namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; // [...] use App\BoardGameBlog\Infrastructure\Sylius\State\Processor\UpdateBoardGameProcessor; use App\BoardGameBlog\Infrastructure\Sylius\State\Provider\BoardGameItemProvider; // [...] provider: BoardGameItemProvider::class, processor: UpdateBoardGameProcessor::class, )] final class BoardGameResource implements ResourceInterface { // [...] }

Slide 240

Slide 240 text

Editing board games provider: BoardGameItemProvider::class, namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; // [...] use App\BoardGameBlog\Infrastructure\Sylius\State\Processor\UpdateBoardGameProcessor; use App\BoardGameBlog\Infrastructure\Sylius\State\Provider\BoardGameItemProvider; use Sylius\Resource\Metadata\Update; // [...] #[Update( processor: UpdateBoardGameProcessor::class, )] final class BoardGameResource implements ResourceInterface { // [...] }

Slide 241

Slide 241 text

Editing board games use App\BoardGameBlog\Infrastructure\Sylius\State\Provider\BoardGameItemProvider; provider: BoardGameItemProvider::class, namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; // [...] use App\BoardGameBlog\Infrastructure\Sylius\State\Processor\UpdateBoardGameProcessor; use Sylius\Resource\Metadata\Update; // [...] #[Update( processor: UpdateBoardGameProcessor::class, )] final class BoardGameResource implements ResourceInterface { // [...] }

Slide 242

Slide 242 text

Editing board games processor: UpdateBoardGameProcessor::class, namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; // [...] use App\BoardGameBlog\Infrastructure\Sylius\State\Processor\UpdateBoardGameProcessor; use App\BoardGameBlog\Infrastructure\Sylius\State\Provider\BoardGameItemProvider; use Sylius\Resource\Metadata\Update; // [...] #[Update( provider: BoardGameItemProvider::class, )] final class BoardGameResource implements ResourceInterface { // [...] }

Slide 243

Slide 243 text

Editing board games use App\BoardGameBlog\Infrastructure\Sylius\State\Processor\UpdateBoardGameProcessor; processor: UpdateBoardGameProcessor::class, namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; // [...] use App\BoardGameBlog\Infrastructure\Sylius\State\Provider\BoardGameItemProvider; use Sylius\Resource\Metadata\Update; // [...] #[Update( provider: BoardGameItemProvider::class, )] final class BoardGameResource implements ResourceInterface { // [...] }

Slide 244

Slide 244 text

// [...] use Sylius\Resource\State\ProviderInterface; final class BoardGameItemProvider implements ProviderInterface { public function __construct(private readonly string $dataDir) {} public function provide(Operation $operation, Context $context): ?BoardGameResource { $request = $context->get(RequestOption::class)?->request(); Assert::notNull($request); $id = $request->attributes->get('id'); Assert::nullOrString($id); [$id, $name, $shortDescription] = $this->getFileData()[$id] ?? null; if (null === $id) { return null; } return new BoardGameResource( id: $id, name: $name, shortDescription: $shortDescription, );

Slide 245

Slide 245 text

final class BoardGameItemProvider implements ProviderInterface // [...] use Sylius\Resource\State\ProviderInterface; { public function __construct(private readonly string $dataDir) {} public function provide(Operation $operation, Context $context): ?BoardGameResource { $request = $context->get(RequestOption::class)?->request(); Assert::notNull($request); $id = $request->attributes->get('id'); Assert::nullOrString($id); [$id, $name, $shortDescription] = $this->getFileData()[$id] ?? null; if (null === $id) { return null; } return new BoardGameResource( id: $id, name: $name, shortDescription: $shortDescription, );

Slide 246

Slide 246 text

use Sylius\Resource\State\ProviderInterface; final class BoardGameItemProvider implements ProviderInterface // [...] { public function __construct(private readonly string $dataDir) {} public function provide(Operation $operation, Context $context): ?BoardGameResource { $request = $context->get(RequestOption::class)?->request(); Assert::notNull($request); $id = $request->attributes->get('id'); Assert::nullOrString($id); [$id, $name, $shortDescription] = $this->getFileData()[$id] ?? null; if (null === $id) { return null; } return new BoardGameResource( id: $id, name: $name, shortDescription: $shortDescription, );

Slide 247

Slide 247 text

public function provide(Operation $operation, Context $context): ?BoardGameResource // [...] use Sylius\Resource\State\ProviderInterface; final class BoardGameItemProvider implements ProviderInterface { public function __construct(private readonly string $dataDir) {} { $request = $context->get(RequestOption::class)?->request(); Assert::notNull($request); $id = $request->attributes->get('id'); Assert::nullOrString($id); [$id, $name, $shortDescription] = $this->getFileData()[$id] ?? null; if (null === $id) { return null; } return new BoardGameResource( id: $id, name: $name, shortDescription: $shortDescription, );

Slide 248

Slide 248 text

$request = $context->get(RequestOption::class)?->request(); Assert::notNull($request); // [...] use Sylius\Resource\State\ProviderInterface; final class BoardGameItemProvider implements ProviderInterface { public function __construct(private readonly string $dataDir) {} public function provide(Operation $operation, Context $context): ?BoardGameResource { $id = $request->attributes->get('id'); Assert::nullOrString($id); [$id, $name, $shortDescription] = $this->getFileData()[$id] ?? null; if (null === $id) { return null; } return new BoardGameResource( id: $id, name: $name, shortDescription: $shortDescription, );

Slide 249

Slide 249 text

$id = $request->attributes->get('id'); Assert::nullOrString($id); // [...] use Sylius\Resource\State\ProviderInterface; final class BoardGameItemProvider implements ProviderInterface { public function __construct(private readonly string $dataDir) {} public function provide(Operation $operation, Context $context): ?BoardGameResource { $request = $context->get(RequestOption::class)?->request(); Assert::notNull($request); [$id, $name, $shortDescription] = $this->getFileData()[$id] ?? null; if (null === $id) { return null; } return new BoardGameResource( id: $id, name: $name, shortDescription: $shortDescription, );

Slide 250

Slide 250 text

[$id, $name, $shortDescription] = $this->getFileData()[$id] ?? null; // [...] use Sylius\Resource\State\ProviderInterface; final class BoardGameItemProvider implements ProviderInterface { public function __construct(private readonly string $dataDir) {} public function provide(Operation $operation, Context $context): ?BoardGameResource { $request = $context->get(RequestOption::class)?->request(); Assert::notNull($request); $id = $request->attributes->get('id'); Assert::nullOrString($id); if (null === $id) { return null; } return new BoardGameResource( id: $id, name: $name, shortDescription: $shortDescription, );

Slide 251

Slide 251 text

if (null === $id) { return null; } // [...] use Sylius\Resource\State\ProviderInterface; final class BoardGameItemProvider implements ProviderInterface { public function __construct(private readonly string $dataDir) {} public function provide(Operation $operation, Context $context): ?BoardGameResource { $request = $context->get(RequestOption::class)?->request(); Assert::notNull($request); $id = $request->attributes->get('id'); Assert::nullOrString($id); [$id, $name, $shortDescription] = $this->getFileData()[$id] ?? null; return new BoardGameResource( id: $id, name: $name, shortDescription: $shortDescription, );

Slide 252

Slide 252 text

return new BoardGameResource( id: $id, name: $name, shortDescription: $shortDescription, ); // [...] use Sylius\Resource\State\ProviderInterface; final class BoardGameItemProvider implements ProviderInterface { public function __construct(private readonly string $dataDir) {} public function provide(Operation $operation, Context $context): ?BoardGameResource { $request = $context->get(RequestOption::class)?->request(); Assert::notNull($request); $id = $request->attributes->get('id'); Assert::nullOrString($id); [$id, $name, $shortDescription] = $this->getFileData()[$id] ?? null; if (null === $id) { return null; }

Slide 253

Slide 253 text

// [...] use Sylius\Resource\State\ProcessorInterface; final class UpdateBoardGameProcessor implements ProcessorInterface { public function process(mixed $data, Operation $operation, Context $context): mixed { Assert::isInstanceOf($data, BoardGameResource::class); $this->updateBoardGame($data); return null; } private function updateBoardGame(BoardGameResource $boardGameResource): void { $fileData = $this->getFileData(); $row = &$fileData[$boardGameResource->id]; $row[1] = $boardGameResource->name; $row[2] = $boardGameResource->shortDescription; $handle = fopen($this->dataDir . '/board_games.csv', 'wb'); foreach ($fileData as $data) { fputcsv($handle, $data);

Slide 254

Slide 254 text

final class UpdateBoardGameProcessor implements ProcessorInterface // [...] use Sylius\Resource\State\ProcessorInterface; { public function process(mixed $data, Operation $operation, Context $context): mixed { Assert::isInstanceOf($data, BoardGameResource::class); $this->updateBoardGame($data); return null; } private function updateBoardGame(BoardGameResource $boardGameResource): void { $fileData = $this->getFileData(); $row = &$fileData[$boardGameResource->id]; $row[1] = $boardGameResource->name; $row[2] = $boardGameResource->shortDescription; $handle = fopen($this->dataDir . '/board_games.csv', 'wb'); foreach ($fileData as $data) { fputcsv($handle, $data);

Slide 255

Slide 255 text

use Sylius\Resource\State\ProcessorInterface; final class UpdateBoardGameProcessor implements ProcessorInterface // [...] { public function process(mixed $data, Operation $operation, Context $context): mixed { Assert::isInstanceOf($data, BoardGameResource::class); $this->updateBoardGame($data); return null; } private function updateBoardGame(BoardGameResource $boardGameResource): void { $fileData = $this->getFileData(); $row = &$fileData[$boardGameResource->id]; $row[1] = $boardGameResource->name; $row[2] = $boardGameResource->shortDescription; $handle = fopen($this->dataDir . '/board_games.csv', 'wb'); foreach ($fileData as $data) { fputcsv($handle, $data);

Slide 256

Slide 256 text

public function process(mixed $data, Operation $operation, Context $context): mixed // [...] use Sylius\Resource\State\ProcessorInterface; final class UpdateBoardGameProcessor implements ProcessorInterface { { Assert::isInstanceOf($data, BoardGameResource::class); $this->updateBoardGame($data); return null; } private function updateBoardGame(BoardGameResource $boardGameResource): void { $fileData = $this->getFileData(); $row = &$fileData[$boardGameResource->id]; $row[1] = $boardGameResource->name; $row[2] = $boardGameResource->shortDescription; $handle = fopen($this->dataDir . '/board_games.csv', 'wb'); foreach ($fileData as $data) { fputcsv($handle, $data);

Slide 257

Slide 257 text

Assert::isInstanceOf($data, BoardGameResource::class); // [...] use Sylius\Resource\State\ProcessorInterface; final class UpdateBoardGameProcessor implements ProcessorInterface { public function process(mixed $data, Operation $operation, Context $context): mixed { $this->updateBoardGame($data); return null; } private function updateBoardGame(BoardGameResource $boardGameResource): void { $fileData = $this->getFileData(); $row = &$fileData[$boardGameResource->id]; $row[1] = $boardGameResource->name; $row[2] = $boardGameResource->shortDescription; $handle = fopen($this->dataDir . '/board_games.csv', 'wb'); foreach ($fileData as $data) { fputcsv($handle, $data);

Slide 258

Slide 258 text

$this->updateBoardGame($data); // [...] use Sylius\Resource\State\ProcessorInterface; final class UpdateBoardGameProcessor implements ProcessorInterface { public function process(mixed $data, Operation $operation, Context $context): mixed { Assert::isInstanceOf($data, BoardGameResource::class); return null; } private function updateBoardGame(BoardGameResource $boardGameResource): void { $fileData = $this->getFileData(); $row = &$fileData[$boardGameResource->id]; $row[1] = $boardGameResource->name; $row[2] = $boardGameResource->shortDescription; $handle = fopen($this->dataDir . '/board_games.csv', 'wb'); foreach ($fileData as $data) { fputcsv($handle, $data);

Slide 259

Slide 259 text

$this->updateBoardGame($data); private function updateBoardGame(BoardGameResource $boardGameResource): void { $fileData = $this->getFileData(); $row = &$fileData[$boardGameResource->id]; $row[1] = $boardGameResource->name; $row[2] = $boardGameResource->shortDescription; $handle = fopen($this->dataDir . '/board_games.csv', 'wb'); foreach ($fileData as $data) { fputcsv($handle, $data); // [...] use Sylius\Resource\State\ProcessorInterface; final class UpdateBoardGameProcessor implements ProcessorInterface { public function process(mixed $data, Operation $operation, Context $context): mixed { Assert::isInstanceOf($data, BoardGameResource::class); return null; }

Slide 260

Slide 260 text

$fileData = $this->getFileData(); $row = &$fileData[$boardGameResource->id]; // [...] use Sylius\Resource\State\ProcessorInterface; final class UpdateBoardGameProcessor implements ProcessorInterface { public function process(mixed $data, Operation $operation, Context $context): mixed { Assert::isInstanceOf($data, BoardGameResource::class); $this->updateBoardGame($data); return null; } private function updateBoardGame(BoardGameResource $boardGameResource): void { $row[1] = $boardGameResource->name; $row[2] = $boardGameResource->shortDescription; $handle = fopen($this->dataDir . '/board_games.csv', 'wb'); foreach ($fileData as $data) { fputcsv($handle, $data);

Slide 261

Slide 261 text

$row[1] = $boardGameResource->name; $row[2] = $boardGameResource->shortDescription; // [...] use Sylius\Resource\State\ProcessorInterface; final class UpdateBoardGameProcessor implements ProcessorInterface { public function process(mixed $data, Operation $operation, Context $context): mixed { Assert::isInstanceOf($data, BoardGameResource::class); $this->updateBoardGame($data); return null; } private function updateBoardGame(BoardGameResource $boardGameResource): void { $fileData = $this->getFileData(); $row = &$fileData[$boardGameResource->id]; $handle = fopen($this->dataDir . '/board_games.csv', 'wb'); foreach ($fileData as $data) { fputcsv($handle, $data);

Slide 262

Slide 262 text

$handle = fopen($this->dataDir . '/board_games.csv', 'wb'); foreach ($fileData as $data) { fputcsv($handle, $data); // [...] use Sylius\Resource\State\ProcessorInterface; final class UpdateBoardGameProcessor implements ProcessorInterface { public function process(mixed $data, Operation $operation, Context $context): mixed { Assert::isInstanceOf($data, BoardGameResource::class); $this->updateBoardGame($data); return null; } private function updateBoardGame(BoardGameResource $boardGameResource): void { $fileData = $this->getFileData(); $row = &$fileData[$boardGameResource->id]; $row[1] = $boardGameResource->name; $row[2] = $boardGameResource->shortDescription;

Slide 263

Slide 263 text

No content

Slide 264

Slide 264 text

No content

Slide 265

Slide 265 text

No content

Slide 266

Slide 266 text

No content

Slide 267

Slide 267 text

Deleting board games

Slide 268

Slide 268 text

Deleting board games namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; // [...] use App\BoardGameBlog\Infrastructure\Sylius\State\Processor\DeleteBoardGameProcessor; use App\BoardGameBlog\Infrastructure\Sylius\State\Provider\BoardGameItemProvider; use Sylius\Resource\Metadata\Delete; // [...] #[Delete( provider: BoardGameItemProvider::class, processor: DeleteBoardGameProcessor::class, )] final class BoardGameResource implements ResourceInterface { // [...] }

Slide 269

Slide 269 text

Deleting board games #[Delete( namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; // [...] use App\BoardGameBlog\Infrastructure\Sylius\State\Processor\DeleteBoardGameProcessor; use App\BoardGameBlog\Infrastructure\Sylius\State\Provider\BoardGameItemProvider; use Sylius\Resource\Metadata\Delete; // [...] provider: BoardGameItemProvider::class, processor: DeleteBoardGameProcessor::class, )] final class BoardGameResource implements ResourceInterface { // [...] }

Slide 270

Slide 270 text

Deleting board games use Sylius\Resource\Metadata\Delete; #[Delete( namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; // [...] use App\BoardGameBlog\Infrastructure\Sylius\State\Processor\DeleteBoardGameProcessor; use App\BoardGameBlog\Infrastructure\Sylius\State\Provider\BoardGameItemProvider; // [...] provider: BoardGameItemProvider::class, processor: DeleteBoardGameProcessor::class, )] final class BoardGameResource implements ResourceInterface { // [...] }

Slide 271

Slide 271 text

Deleting board games provider: BoardGameItemProvider::class, namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; // [...] use App\BoardGameBlog\Infrastructure\Sylius\State\Processor\DeleteBoardGameProcessor; use App\BoardGameBlog\Infrastructure\Sylius\State\Provider\BoardGameItemProvider; use Sylius\Resource\Metadata\Delete; // [...] #[Delete( processor: DeleteBoardGameProcessor::class, )] final class BoardGameResource implements ResourceInterface { // [...] }

Slide 272

Slide 272 text

Deleting board games use App\BoardGameBlog\Infrastructure\Sylius\State\Provider\BoardGameItemProvider; provider: BoardGameItemProvider::class, namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; // [...] use App\BoardGameBlog\Infrastructure\Sylius\State\Processor\DeleteBoardGameProcessor; use Sylius\Resource\Metadata\Delete; // [...] #[Delete( processor: DeleteBoardGameProcessor::class, )] final class BoardGameResource implements ResourceInterface { // [...] }

Slide 273

Slide 273 text

Deleting board games processor: DeleteBoardGameProcessor::class, namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; // [...] use App\BoardGameBlog\Infrastructure\Sylius\State\Processor\DeleteBoardGameProcessor; use App\BoardGameBlog\Infrastructure\Sylius\State\Provider\BoardGameItemProvider; use Sylius\Resource\Metadata\Delete; // [...] #[Delete( provider: BoardGameItemProvider::class, )] final class BoardGameResource implements ResourceInterface { // [...] }

Slide 274

Slide 274 text

Deleting board games use App\BoardGameBlog\Infrastructure\Sylius\State\Processor\DeleteBoardGameProcessor; processor: DeleteBoardGameProcessor::class, namespace App\BoardGameBlog\Infrastructure\Sylius\Resource; // [...] use App\BoardGameBlog\Infrastructure\Sylius\State\Provider\BoardGameItemProvider; use Sylius\Resource\Metadata\Delete; // [...] #[Delete( provider: BoardGameItemProvider::class, )] final class BoardGameResource implements ResourceInterface { // [...] }

Slide 275

Slide 275 text

// [...] use Sylius\Resource\State\ProcessorInterface; final class DeleteBoardGameProcessor implements ProcessorInterface { public function process(mixed $data, Operation $operation, Context $context): mixed { Assert::isInstanceOf($data, BoardGameResource::class); $this->deleteBoardGame($data); return null; } private function deleteBoardGame(BoardGameResource $boardGameResource): void { $fileData = $this->getFileData(); unset($fileData[$boardGameResource->id]); $handle = fopen($this->dataDir . '/board_games.csv', 'wb'); foreach ($fileData as $data) { fputcsv($handle, $data); } fclose($handle);

Slide 276

Slide 276 text

final class DeleteBoardGameProcessor implements ProcessorInterface // [...] use Sylius\Resource\State\ProcessorInterface; { public function process(mixed $data, Operation $operation, Context $context): mixed { Assert::isInstanceOf($data, BoardGameResource::class); $this->deleteBoardGame($data); return null; } private function deleteBoardGame(BoardGameResource $boardGameResource): void { $fileData = $this->getFileData(); unset($fileData[$boardGameResource->id]); $handle = fopen($this->dataDir . '/board_games.csv', 'wb'); foreach ($fileData as $data) { fputcsv($handle, $data); } fclose($handle);

Slide 277

Slide 277 text

use Sylius\Resource\State\ProcessorInterface; final class DeleteBoardGameProcessor implements ProcessorInterface // [...] { public function process(mixed $data, Operation $operation, Context $context): mixed { Assert::isInstanceOf($data, BoardGameResource::class); $this->deleteBoardGame($data); return null; } private function deleteBoardGame(BoardGameResource $boardGameResource): void { $fileData = $this->getFileData(); unset($fileData[$boardGameResource->id]); $handle = fopen($this->dataDir . '/board_games.csv', 'wb'); foreach ($fileData as $data) { fputcsv($handle, $data); } fclose($handle);

Slide 278

Slide 278 text

public function process(mixed $data, Operation $operation, Context $context): mixed // [...] use Sylius\Resource\State\ProcessorInterface; final class DeleteBoardGameProcessor implements ProcessorInterface { { Assert::isInstanceOf($data, BoardGameResource::class); $this->deleteBoardGame($data); return null; } private function deleteBoardGame(BoardGameResource $boardGameResource): void { $fileData = $this->getFileData(); unset($fileData[$boardGameResource->id]); $handle = fopen($this->dataDir . '/board_games.csv', 'wb'); foreach ($fileData as $data) { fputcsv($handle, $data); } fclose($handle);

Slide 279

Slide 279 text

Assert::isInstanceOf($data, BoardGameResource::class); // [...] use Sylius\Resource\State\ProcessorInterface; final class DeleteBoardGameProcessor implements ProcessorInterface { public function process(mixed $data, Operation $operation, Context $context): mixed { $this->deleteBoardGame($data); return null; } private function deleteBoardGame(BoardGameResource $boardGameResource): void { $fileData = $this->getFileData(); unset($fileData[$boardGameResource->id]); $handle = fopen($this->dataDir . '/board_games.csv', 'wb'); foreach ($fileData as $data) { fputcsv($handle, $data); } fclose($handle);

Slide 280

Slide 280 text

$this->deleteBoardGame($data); // [...] use Sylius\Resource\State\ProcessorInterface; final class DeleteBoardGameProcessor implements ProcessorInterface { public function process(mixed $data, Operation $operation, Context $context): mixed { Assert::isInstanceOf($data, BoardGameResource::class); return null; } private function deleteBoardGame(BoardGameResource $boardGameResource): void { $fileData = $this->getFileData(); unset($fileData[$boardGameResource->id]); $handle = fopen($this->dataDir . '/board_games.csv', 'wb'); foreach ($fileData as $data) { fputcsv($handle, $data); } fclose($handle);

Slide 281

Slide 281 text

$this->deleteBoardGame($data); private function deleteBoardGame(BoardGameResource $boardGameResource): void { $fileData = $this->getFileData(); unset($fileData[$boardGameResource->id]); $handle = fopen($this->dataDir . '/board_games.csv', 'wb'); foreach ($fileData as $data) { fputcsv($handle, $data); } fclose($handle); // [...] use Sylius\Resource\State\ProcessorInterface; final class DeleteBoardGameProcessor implements ProcessorInterface { public function process(mixed $data, Operation $operation, Context $context): mixed { Assert::isInstanceOf($data, BoardGameResource::class); return null; }

Slide 282

Slide 282 text

$fileData = $this->getFileData(); unset($fileData[$boardGameResource->id]); // [...] use Sylius\Resource\State\ProcessorInterface; final class DeleteBoardGameProcessor implements ProcessorInterface { public function process(mixed $data, Operation $operation, Context $context): mixed { Assert::isInstanceOf($data, BoardGameResource::class); $this->deleteBoardGame($data); return null; } private function deleteBoardGame(BoardGameResource $boardGameResource): void { $handle = fopen($this->dataDir . '/board_games.csv', 'wb'); foreach ($fileData as $data) { fputcsv($handle, $data); } fclose($handle);

Slide 283

Slide 283 text

$handle = fopen($this->dataDir . '/board_games.csv', 'wb'); foreach ($fileData as $data) { fputcsv($handle, $data); } fclose($handle); // [...] use Sylius\Resource\State\ProcessorInterface; final class DeleteBoardGameProcessor implements ProcessorInterface { public function process(mixed $data, Operation $operation, Context $context): mixed { Assert::isInstanceOf($data, BoardGameResource::class); $this->deleteBoardGame($data); return null; } private function deleteBoardGame(BoardGameResource $boardGameResource): void { $fileData = $this->getFileData(); unset($fileData[$boardGameResource->id]);

Slide 284

Slide 284 text

No content

Slide 285

Slide 285 text

No content

Slide 286

Slide 286 text

No content

Slide 287

Slide 287 text

Sorting board games

Slide 288

Slide 288 text

Sorting board games final class BoardGameGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder ->setProvider(BoardGameGridProvider::class) ->orderBy('name', 'asc') ->addField( StringField::create('name') ->setLabel('Name') ->setSortable(true), ) // [...] ; } // [...] }

Slide 289

Slide 289 text

Sorting board games ->addField( StringField::create('name') ->setLabel('Name') ->setSortable(true), ) final class BoardGameGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder ->setProvider(BoardGameGridProvider::class) ->orderBy('name', 'asc') // [...] ; } // [...] }

Slide 290

Slide 290 text

Sorting board games ->setSortable(true), final class BoardGameGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder ->setProvider(BoardGameGridProvider::class) ->orderBy('name', 'asc') ->addField( StringField::create('name') ->setLabel('Name') ) // [...] ; } // [...] }

Slide 291

Slide 291 text

Sorting board games ->orderBy('name', 'asc') final class BoardGameGrid extends AbstractGrid implements ResourceAwareGridInterface { // [...] public function buildGrid(GridBuilderInterface $gridBuilder): void { $gridBuilder ->setProvider(BoardGameGridProvider::class) ->addField( StringField::create('name') ->setLabel('Name') ->setSortable(true), ) // [...] ; } // [...] }

Slide 292

Slide 292 text

No content

Slide 293

Slide 293 text

No content

Slide 294

Slide 294 text

final class BoardGameGridProvider implements DataProviderInterface { public function getData(Grid $grid, Parameters $parameters): Pagerfanta { $data = []; $fileData = $this->getFileData(); $sorting = $parameters->get('sorting') ?? []; $fileData = $this->sortData($fileData, $sorting); // [...] } private function sortData(array $data, array $sorting): array { if ('asc' === ($sorting['name'] ?? null)) { usort($data, [$this, 'sortByNameAsc']); } if ('desc' === ($sorting['name'] ?? null)) { usort($data, [$this, 'sortByNameDesc']); } return $data;

Slide 295

Slide 295 text

$sorting = $parameters->get('sorting') ?? []; final class BoardGameGridProvider implements DataProviderInterface { public function getData(Grid $grid, Parameters $parameters): Pagerfanta { $data = []; $fileData = $this->getFileData(); $fileData = $this->sortData($fileData, $sorting); // [...] } private function sortData(array $data, array $sorting): array { if ('asc' === ($sorting['name'] ?? null)) { usort($data, [$this, 'sortByNameAsc']); } if ('desc' === ($sorting['name'] ?? null)) { usort($data, [$this, 'sortByNameDesc']); } return $data;

Slide 296

Slide 296 text

$fileData = $this->sortData($fileData, $sorting); final class BoardGameGridProvider implements DataProviderInterface { public function getData(Grid $grid, Parameters $parameters): Pagerfanta { $data = []; $fileData = $this->getFileData(); $sorting = $parameters->get('sorting') ?? []; // [...] } private function sortData(array $data, array $sorting): array { if ('asc' === ($sorting['name'] ?? null)) { usort($data, [$this, 'sortByNameAsc']); } if ('desc' === ($sorting['name'] ?? null)) { usort($data, [$this, 'sortByNameDesc']); } return $data;

Slide 297

Slide 297 text

$fileData = $this->sortData($fileData, $sorting); private function sortData(array $data, array $sorting): array { if ('asc' === ($sorting['name'] ?? null)) { usort($data, [$this, 'sortByNameAsc']); } if ('desc' === ($sorting['name'] ?? null)) { usort($data, [$this, 'sortByNameDesc']); } return $data; final class BoardGameGridProvider implements DataProviderInterface { public function getData(Grid $grid, Parameters $parameters): Pagerfanta { $data = []; $fileData = $this->getFileData(); $sorting = $parameters->get('sorting') ?? []; // [...] }

Slide 298

Slide 298 text

final class BoardGameGridProvider implements DataProviderInterface { // [...] private function sortData(array $data, array $sorting): array { if ('asc' === ($sorting['name'] ?? null)) { usort($data, [$this, 'sortByNameAsc']); } if ('desc' === ($sorting['name'] ?? null)) { usort($data, [$this, 'sortByNameDesc']); } return $data; } private function sortByNameAsc($a, $b): int { return strcmp($a[1], $b[1]); } private function sortByNameDesc($a, $b): int { return strcmp($b[1], $a[1]); }

Slide 299

Slide 299 text

if ('asc' === ($sorting['name'] ?? null)) { usort($data, [$this, 'sortByNameAsc']); } final class BoardGameGridProvider implements DataProviderInterface { // [...] private function sortData(array $data, array $sorting): array { if ('desc' === ($sorting['name'] ?? null)) { usort($data, [$this, 'sortByNameDesc']); } return $data; } private function sortByNameAsc($a, $b): int { return strcmp($a[1], $b[1]); } private function sortByNameDesc($a, $b): int { return strcmp($b[1], $a[1]); }

Slide 300

Slide 300 text

if ('asc' === ($sorting['name'] ?? null)) { usort($data, [$this, 'sortByNameAsc']); } private function sortByNameAsc($a, $b): int { return strcmp($a[1], $b[1]); } final class BoardGameGridProvider implements DataProviderInterface { // [...] private function sortData(array $data, array $sorting): array { if ('desc' === ($sorting['name'] ?? null)) { usort($data, [$this, 'sortByNameDesc']); } return $data; } private function sortByNameDesc($a, $b): int { return strcmp($b[1], $a[1]); }

Slide 301

Slide 301 text

if ('desc' === ($sorting['name'] ?? null)) { usort($data, [$this, 'sortByNameDesc']); } final class BoardGameGridProvider implements DataProviderInterface { // [...] private function sortData(array $data, array $sorting): array { if ('asc' === ($sorting['name'] ?? null)) { usort($data, [$this, 'sortByNameAsc']); } return $data; } private function sortByNameAsc($a, $b): int { return strcmp($a[1], $b[1]); } private function sortByNameDesc($a, $b): int { return strcmp($b[1], $a[1]); }

Slide 302

Slide 302 text

if ('desc' === ($sorting['name'] ?? null)) { usort($data, [$this, 'sortByNameDesc']); } private function sortByNameDesc($a, $b): int { return strcmp($b[1], $a[1]); } final class BoardGameGridProvider implements DataProviderInterface { // [...] private function sortData(array $data, array $sorting): array { if ('asc' === ($sorting['name'] ?? null)) { usort($data, [$this, 'sortByNameAsc']); } return $data; } private function sortByNameAsc($a, $b): int { return strcmp($a[1], $b[1]); }

Slide 303

Slide 303 text

No content

Slide 304

Slide 304 text

No content

Slide 305

Slide 305 text

Default sorting Is it sorted by name?

Slide 306

Slide 306 text

No content

Slide 307

Slide 307 text

final class BoardGameGridProvider implements DataProviderInterface { public function getData(Grid $grid, Parameters $parameters): Pagerfanta { $data = []; $fileData = $this->getFileData(); $sorting = $parameters->get('sorting') ?? []; $fileData = $this->sortData($fileData, $sorting); // [...] } // [...] }

Slide 308

Slide 308 text

$sorting = $parameters->get('sorting') ?? []; final class BoardGameGridProvider implements DataProviderInterface { public function getData(Grid $grid, Parameters $parameters): Pagerfanta { $data = []; $fileData = $this->getFileData(); $fileData = $this->sortData($fileData, $sorting); // [...] } // [...] }

Slide 309

Slide 309 text

$sorting = $parameters->get('sorting') ?? $grid->getSorting(); final class BoardGameGridProvider implements DataProviderInterface { public function getData(Grid $grid, Parameters $parameters): Pagerfanta { $data = []; $fileData = $this->getFileData(); $fileData = $this->sortData($fileData, $sorting); // [...] } // [...] }

Slide 310

Slide 310 text

No content

Slide 311

Slide 311 text

What’s next?

Slide 312

Slide 312 text

What’s next? Stable release

Slide 313

Slide 313 text

What’s next? Stable release Reunite bundle & component into same package

Slide 314

Slide 314 text

What’s next? Stable release Reunite bundle & component into same package Remove Kernel events (WIP thx to Vasilvestre)

Slide 315

Slide 315 text

What’s next? Stable release Reunite bundle & component into same package Remove Kernel events (WIP thx to Vasilvestre) PHP configuration

Slide 316

Slide 316 text

Reunite bundle & component into same package Before After Sylius\Bundle\ResourceBundle Sylius\Component\Resource Sylius\Resource

Slide 317

Slide 317 text

Kernel Events

Slide 318

Slide 318 text

No content

Slide 319

Slide 319 text

PHP configuration Open-source cooperation

Slide 320

Slide 320 text

Resource configurator // config/package/sylius_resource.php namespace Symfony\Component\DependencyInjection\Loader\Configurator; use App\Entity\Book; use App\Entity\Subscription; use Sylius\Component\Resource\Metadata\ResourceMetadata; use Sylius\Component\Loader\Configuration\ResourceConfigurator; return static function (ResourceConfigurator $resourceConfigurator): void { $resourceConfigurator ->withResource((new ResourceMetadata(Book::class)) ->withRoutePrefix('admin') ->withOperations([ new Index(), new Create(), new Update(), new Delete(), ]) ) ->withResource((new ResourceMetadata(Subscription::class)) ->withOperations([ new Index(), ]) )

Slide 321

Slide 321 text

Resource configurator return static function (ResourceConfigurator $resourceConfigurator): void { // config/package/sylius_resource.php namespace Symfony\Component\DependencyInjection\Loader\Configurator; use App\Entity\Book; use App\Entity\Subscription; use Sylius\Component\Resource\Metadata\ResourceMetadata; use Sylius\Component\Loader\Configuration\ResourceConfigurator; $resourceConfigurator ->withResource((new ResourceMetadata(Book::class)) ->withRoutePrefix('admin') ->withOperations([ new Index(), new Create(), new Update(), new Delete(), ]) ) ->withResource((new ResourceMetadata(Subscription::class)) ->withOperations([ new Index(), ]) )

Slide 322

Slide 322 text

Resource configurator use Sylius\Component\Loader\Configuration\ResourceConfigurator; return static function (ResourceConfigurator $resourceConfigurator): void { // config/package/sylius_resource.php namespace Symfony\Component\DependencyInjection\Loader\Configurator; use App\Entity\Book; use App\Entity\Subscription; use Sylius\Component\Resource\Metadata\ResourceMetadata; $resourceConfigurator ->withResource((new ResourceMetadata(Book::class)) ->withRoutePrefix('admin') ->withOperations([ new Index(), new Create(), new Update(), new Delete(), ]) ) ->withResource((new ResourceMetadata(Subscription::class)) ->withOperations([ new Index(), ]) )

Slide 323

Slide 323 text

Resource configurator ->withResource((new ResourceMetadata(Book::class)) // config/package/sylius_resource.php namespace Symfony\Component\DependencyInjection\Loader\Configurator; use App\Entity\Book; use App\Entity\Subscription; use Sylius\Component\Resource\Metadata\ResourceMetadata; use Sylius\Component\Loader\Configuration\ResourceConfigurator; return static function (ResourceConfigurator $resourceConfigurator): void { $resourceConfigurator ->withRoutePrefix('admin') ->withOperations([ new Index(), new Create(), new Update(), new Delete(), ]) ) ->withResource((new ResourceMetadata(Subscription::class)) ->withOperations([ new Index(), ]) )

Slide 324

Slide 324 text

Resource configurator use Sylius\Component\Resource\Metadata\ResourceMetadata; ->withResource((new ResourceMetadata(Book::class)) // config/package/sylius_resource.php namespace Symfony\Component\DependencyInjection\Loader\Configurator; use App\Entity\Book; use App\Entity\Subscription; use Sylius\Component\Loader\Configuration\ResourceConfigurator; return static function (ResourceConfigurator $resourceConfigurator): void { $resourceConfigurator ->withRoutePrefix('admin') ->withOperations([ new Index(), new Create(), new Update(), new Delete(), ]) ) ->withResource((new ResourceMetadata(Subscription::class)) ->withOperations([ new Index(), ]) )

Slide 325

Slide 325 text

Resource configurator ->withRoutePrefix('admin') // config/package/sylius_resource.php namespace Symfony\Component\DependencyInjection\Loader\Configurator; use App\Entity\Book; use App\Entity\Subscription; use Sylius\Component\Resource\Metadata\ResourceMetadata; use Sylius\Component\Loader\Configuration\ResourceConfigurator; return static function (ResourceConfigurator $resourceConfigurator): void { $resourceConfigurator ->withResource((new ResourceMetadata(Book::class)) ->withOperations([ new Index(), new Create(), new Update(), new Delete(), ]) ) ->withResource((new ResourceMetadata(Subscription::class)) ->withOperations([ new Index(), ]) )

Slide 326

Slide 326 text

Resource configurator ->withOperations([ new Index(), new Create(), new Update(), new Delete(), ]) // config/package/sylius_resource.php namespace Symfony\Component\DependencyInjection\Loader\Configurator; use App\Entity\Book; use App\Entity\Subscription; use Sylius\Component\Resource\Metadata\ResourceMetadata; use Sylius\Component\Loader\Configuration\ResourceConfigurator; return static function (ResourceConfigurator $resourceConfigurator): void { $resourceConfigurator ->withResource((new ResourceMetadata(Book::class)) ->withRoutePrefix('admin') ) ->withResource((new ResourceMetadata(Subscription::class)) ->withOperations([ new Index(), ]) )

Slide 327

Slide 327 text

Resource configurator ->withResource((new ResourceMetadata(Subscription::class)) // config/package/sylius_resource.php namespace Symfony\Component\DependencyInjection\Loader\Configurator; use App\Entity\Book; use App\Entity\Subscription; use Sylius\Component\Resource\Metadata\ResourceMetadata; use Sylius\Component\Loader\Configuration\ResourceConfigurator; return static function (ResourceConfigurator $resourceConfigurator): void { $resourceConfigurator ->withResource((new ResourceMetadata(Book::class)) ->withRoutePrefix('admin') ->withOperations([ new Index(), new Create(), new Update(), new Delete(), ]) ) ->withOperations([ new Index(), ]) )

Slide 328

Slide 328 text

Resource configurator ->withOperations([ new Index(), ]) // config/package/sylius_resource.php namespace Symfony\Component\DependencyInjection\Loader\Configurator; use App\Entity\Book; use App\Entity\Subscription; use Sylius\Component\Resource\Metadata\ResourceMetadata; use Sylius\Component\Loader\Configuration\ResourceConfigurator; return static function (ResourceConfigurator $resourceConfigurator): void { $resourceConfigurator ->withResource((new ResourceMetadata(Book::class)) ->withRoutePrefix('admin') ->withOperations([ new Index(), new Create(), new Update(), new Delete(), ]) ) ->withResource((new ResourceMetadata(Subscription::class)) )

Slide 329

Slide 329 text

// config/api_platform/resources.php namespace Symfony\Component\DependencyInjection\Loader\Configurator; use App\Entity\Book; use App\Entity\Subscription; use ApiPlatform\Metadata\ApiResource; use ApiPlatorm\Loader\Configuration\ApiResourceConfigurator; return static function (ApiResourceConfigurator $resourceConfigurator): void { $resourceConfigurator ->withResource((new ApiResource(Book::class)) ->withRoutePrefix('admin') ->withOperations([ new GetCollection(), new Post(), new Put(), new Delete(), ]) ) ; };

Slide 330

Slide 330 text

return static function (ApiResourceConfigurator $resourceConfigurator): void { // config/api_platform/resources.php namespace Symfony\Component\DependencyInjection\Loader\Configurator; use App\Entity\Book; use App\Entity\Subscription; use ApiPlatform\Metadata\ApiResource; use ApiPlatorm\Loader\Configuration\ApiResourceConfigurator; $resourceConfigurator ->withResource((new ApiResource(Book::class)) ->withRoutePrefix('admin') ->withOperations([ new GetCollection(), new Post(), new Put(), new Delete(), ]) ) ; };

Slide 331

Slide 331 text

use ApiPlatorm\Loader\Configuration\ApiResourceConfigurator; return static function (ApiResourceConfigurator $resourceConfigurator): void { // config/api_platform/resources.php namespace Symfony\Component\DependencyInjection\Loader\Configurator; use App\Entity\Book; use App\Entity\Subscription; use ApiPlatform\Metadata\ApiResource; $resourceConfigurator ->withResource((new ApiResource(Book::class)) ->withRoutePrefix('admin') ->withOperations([ new GetCollection(), new Post(), new Put(), new Delete(), ]) ) ; };

Slide 332

Slide 332 text

->withResource((new ApiResource(Book::class)) // config/api_platform/resources.php namespace Symfony\Component\DependencyInjection\Loader\Configurator; use App\Entity\Book; use App\Entity\Subscription; use ApiPlatform\Metadata\ApiResource; use ApiPlatorm\Loader\Configuration\ApiResourceConfigurator; return static function (ApiResourceConfigurator $resourceConfigurator): void { $resourceConfigurator ->withRoutePrefix('admin') ->withOperations([ new GetCollection(), new Post(), new Put(), new Delete(), ]) ) ; };

Slide 333

Slide 333 text

use ApiPlatform\Metadata\ApiResource; ->withResource((new ApiResource(Book::class)) // config/api_platform/resources.php namespace Symfony\Component\DependencyInjection\Loader\Configurator; use App\Entity\Book; use App\Entity\Subscription; use ApiPlatorm\Loader\Configuration\ApiResourceConfigurator; return static function (ApiResourceConfigurator $resourceConfigurator): void { $resourceConfigurator ->withRoutePrefix('admin') ->withOperations([ new GetCollection(), new Post(), new Put(), new Delete(), ]) ) ; };

Slide 334

Slide 334 text

->withRoutePrefix('admin') // config/api_platform/resources.php namespace Symfony\Component\DependencyInjection\Loader\Configurator; use App\Entity\Book; use App\Entity\Subscription; use ApiPlatform\Metadata\ApiResource; use ApiPlatorm\Loader\Configuration\ApiResourceConfigurator; return static function (ApiResourceConfigurator $resourceConfigurator): void { $resourceConfigurator ->withResource((new ApiResource(Book::class)) ->withOperations([ new GetCollection(), new Post(), new Put(), new Delete(), ]) ) ; };

Slide 335

Slide 335 text

->withOperations([ new GetCollection(), new Post(), new Put(), new Delete(), ]) // config/api_platform/resources.php namespace Symfony\Component\DependencyInjection\Loader\Configurator; use App\Entity\Book; use App\Entity\Subscription; use ApiPlatform\Metadata\ApiResource; use ApiPlatorm\Loader\Configuration\ApiResourceConfigurator; return static function (ApiResourceConfigurator $resourceConfigurator): void { $resourceConfigurator ->withResource((new ApiResource(Book::class)) ->withRoutePrefix('admin') ) ; };

Slide 336

Slide 336 text

No content

Slide 337

Slide 337 text

Now, it's your turn to give it a try. @loic_425 @loic425